Singularity

Built and working

What it does

Everything here works today. What does not exist yet is further down, named plainly, because a page that only lists strengths is a page you cannot trust about anything.

One colour decides everything

The look

Pick a seed colour and the whole application is derived from it while it is running — surfaces, accents, every stylesheet token, and the accretion disk of the hole itself. No restart, no theme files. Try it: these retint this page and the background behind it, using the same rule the program uses.

Or put your own picture behind everything instead — an animated GIF, a WebP, a still image. There is a dim slider, and it is not decoration: every panel in the client is glass, so a bright picture makes the conversation hard to read.

Depth from layers

The rail, the sidebar and the conversation each sit a real step lighter than the one behind, so they read as separate planes without a single border drawn.

Colour is information

The status dots are the one thing the seed never touches. Green, yellow and red have to keep meaning online, away and busy whatever else changes.

Even the title bar

It belongs to Windows rather than Qt, so it is recoloured through the system instead of replaced by a hand made one. Snap layouts and double click to maximise keep working, and there is still no seam across the top.

A hue-less seed

Black and grey have no hue, and scaling one would leave the disk unlit — so those take a silver branch instead. That is the default, and it is what you are looking at.

The background you are looking at

Drawn, not filmed

This is not a video and not a picture of the program. It is the program's own shader, recompiled for the browser — the same bent rays, the same photon ring, the same bright edge where the disk turns toward you.

A detail worth the trouble: the spiral's phase is stored as a cosine and a sine rather than as an angle. An angle wraps from +π to −π, and smoothing across that seam would average two nearly identical directions into a wrong one and draw a hard line across the disk.

Measured, not guessed

Why opening a channel is instant

It was not, for a while. Three attempts went into making the drawing faster before anybody timed it, and the timing ended the argument in one line.

So the wait is not made shorter, it is moved. Opening a server begins fetching its first few channels, and moving the pointer across a channel's name begins fetching that one. Between noticing a channel and clicking it there is a fifth of a second to a whole second of human time, and the round trip fits inside it.

Guessing ahead must never get in the way of the real thing, so it runs one request at a time, stops while a channel somebody actually opened is loading, takes six channels per server rather than forty, and gives up entirely the first time Discord says it is being asked too often.

The stutter that was left

It was never the messages

With the network moved out of the way a stutter remained, and it matched nothing in the log: the whole conversation being laid out again, several times a second, with no request in front of it. The client was spending 67 to 91 ms where the text engine alone spends 14. The difference was the pictures, and three separate things were paying for them over and over.

And then it was measured again

2.7 GB, to show less than Discord

A client that uses four times the memory of the thing it replaces has no reason to exist. A screenshot of a task manager found this, because memory was the one thing the log never mentioned. It does now — the working set, beside what is holding it, every minute.

It settled at 347 MB, measured twice a minute apart, with the heap moving by one megabyte between readings — not a leak — and the largest single block at 31 MB, so not a forgotten buffer either. Most of what was left after the cache work turned out not to be a cache at all: it was four hundred messages held in one channel and the conversation being rebuilt several times a second, which are the two bugs below.

The last of it

Forty, not a hundred

With memory written down every minute, the log gave up the last piece. Building the markup for a hundred messages is 1 ms. Laying them out is 42 to 197 — and that cost is paid per message. A hundred were being measured to show the ten or fifteen that fit on a screen, on every channel opened, every time.

A channel now draws its newest forty. Scrolling to the top draws forty more, instantly and with no request at all, because those messages were already here and simply were not drawn. Only when everything held is on screen is there anything to ask Discord for. Nothing about what gets fetched changed — this is about what the text engine is asked to measure.

Three bugs, one mistake

A window needs a far edge, and a place needs a name

Drawing forty worked and then grew without a ceiling: 40, 90, 150, 200, 250, 300, 350 messages in twenty seconds, and a redraw that had come down to 22 ms was back at 301. Capping it moved the runaway one level down — four hundred messages pulled from Discord in 1.7 seconds, the conversation rebuilt under the reader every eighty milliseconds.

Both are the same mistake. Reaching the top is a position, and a position stays true while nobody moves — so anything hung off it fires again on the next scroll event whether or not the person did anything. It is an action now, and an action happens once.

The third was keeping the reader's place as a number of pixels. The document changes height when messages arrive above, when the window drops messages below, when an edit lands, when a picture loads — so a pixel count means something different after any of those, and three separate pieces of arithmetic each got one case right and the rest wrong. The message under the top edge is the one being read; putting that back is the whole job. One piece of code now, none of it arithmetic on pixels, and tested on its own: park the view on a message, insert fifty above it, and the same message returns to the top edge to the pixel.

Four fixes, each of which sounds like silence

How a call actually works

Getting sound in and out took four separate fixes, every one of which looked like the whole problem at the time. They are written down because all four present identically: nothing comes out.

If a call is ever silent again, the log prints a tally every five seconds and a named reason for every frame thrown away. That line exists because reading the log found in one run what five rounds of theorising could not.

Absent, not switched off

What it never sends

Most of the tracking people worry about is missing — not because a setting disables it, but because the code to do it was never written. That is worth stating plainly rather than claiming as a feature.

Analytics events

The official client posts to an endpoint called /science as you click around. Singularity never calls it.

Read receipts

Nothing tells Discord which messages you have looked at, or when.

A real fingerprint

The client details sent on sign-in are fixed numbers written into the source, not your actual Windows version, locale or hardware — and they are identical for everyone running Singularity.

Session correlation

The fields the official client fills with identifiers linking your sessions together are sent empty.

Game detection

Nothing looks at what programs you have open.

Third party images

Pictures come only from Discord's own hosts.

What the Anonymous plugin genuinely does is the part Singularity does send and can stop sending. It strips tracking codes out of links before they leave. Because it rewrites what you say, it tests itself against six known cases every time it loads — and if any comes out wrong it refuses to touch messages for the rest of the session and says so. A tracking code getting through is a small harm. A broken link the sender cannot see is a worse one.

Nothing on disk to swap out

Seven plugins, inside the binary

There is no plugin folder, so there is no file for anything else to replace. Each one has its own settings page.

The honest part

What is not built

Roughly in the order it is worth doing.

It is also Windows only, and unsigned. Windows will warn that the publisher is unknown, because a code signing certificate costs money every year and this is one person's project.

One setup program

Get it

It installs for you only and never asks for administrator. There is no service, no driver and nothing shared, so there is nothing to elevate for — and a small program asking for rights it does not need is how it starts looking untrustworthy.

There is no wizard either. Every page one would have shown asks something already decided by running it — where to put it, whether to continue, whether to start it afterwards. What you get is one dark window with the hole turning in it, and then the program.

Updating

The program looks for a newer version a few seconds after it starts, and quietly: an up to date copy says nothing at all. Agreeing does the whole thing — downloads, installs itself and starts again. No second dialog, no installer to click through, because by then there is nothing left to decide.

Uninstalling

Asks whether to remove your saved sign-in and settings, and defaults to keeping them. Those live in your profile rather than the install folder, so removing the program does not silently take the account with it.

Where the source is

Private. The installers are published in a separate public repository, because an updater pointed at a private one would need a token shipped inside the program — and anything shipped inside a program can be taken back out of it.