hair on the circuits

software changeling

2026-10-04T00:00:00Z

Talking about Star Trek, AI and the future of software.

In the Star Trek universe, the Changelings are an alien race famous for their shape-shifting abilities. They exist natively as a gel-like, copper-colored liquid, the Great Link. When needed, they hold the form of a person, an animal, an everyday object, even fire, and then slip back into the pool.

I think software is heading in that direction.

For decades, computing has forced human thought into static molds: windows, menus, file trees, monoliths like Microsoft Word. We bent our minds to fit the software, not the other way around.

Stop a minute and think about how your own mind works.

Visualize this word: Pasta.
Done? Now remember the flavor of what you ate last night.
Now imagine your best friend telling you a joke.

The brain doesn't have a single "universal" way of working. It is a set of ever-changing expressions of what you want in the moment: images, sounds, sensations, memories, all associating fluidly. Software was never meant to be this rigid, and for the first time it can start to bend toward the shape of the mind instead of the opposite.

If software can take any shape imaginable, why stay bound to generic tools built for the average user?

Generative models and code synthesis are what break the mold. Software no longer needs to be compiled once and shipped frozen to millions of identical screens. It can be ephemeral: scaffolded on the fly for a specific problem, mutated to your preferences, and dissolved when it has served its purpose. Interfaces generated just-in-time, programs written from a plain-language description, tools that rewrite themselves while you use them.

Picture running PowerPoint and telling it that you want (for some reason) everything to be pink. The software obeys and mutates. Personal software. Goodbye one-size-fits-all Microsoft Word? I don't know exactly how it will look, but I can say that I'm excited.

That excitement comes with a real tension. Can this liquid ocean of code run locally, on small and efficient hardware, with the data staying in your hands? Or does it trap us inside a centralized corporate monolith that burns enormous amounts of energy? The Changelings shape themselves; they don't rent their form from someone else. I'd like software to work the same way.

And what about operating systems? Everybody is running their heart's desire on their phone, tablet and laptop. Do people really care what's underneath? Do the people that sell it to use do?

I imagine software in the future as a massive ocean of consciousness. Everybody drinks from it. Everybody contributes.

Differentiable Robotics

2026-09-29T00:00:00Z

I really find this method of training policies really intersting.

Maybe I should write a bit more. But basically, an alternative to Zeroth-order methods to train policies for robots using differentiable simulators, like MuJoCo's MJX.

Contrastive Loss

2026-09-28T00:00:00Z

Some things i did to make 2 (or more) latent encoders talk to each other.

Let's say you have 2 latent encoders, that for some reason you want to them to align. One turns images into vectors, the other turns text into vectors, and you want a photo of a dog and the sentence "a photo of a dog" to land on nearby points in the same space. If you can do that, a lot comes for free: search images with text, classifiy images into categories you never trained on, compare a sentence to thousands of pictures with a single dot product.

The two encoders don't have to be different modalities. They can be the same network looking at two augmented crops of one image SimCLR, or an audio encoder and a text decoder, or a user encoder and an item encoder in an recommender. The question is always the same: how do you train two encoders so that things that belong together end up togeter?

First, why it fails?

The first thing you'd try: make matching pairs (image, caption) and minimze the distance between their embeddings.

\text{loss} = || f( \text{image} ) - g( \text{text} ) ) || ^ 2

It works really good, so good that it collapses. The easisest way to make every pair close to is to map everything to the same point. The loss goes to zero, and the model's embeddings result useless.

The fix is the whole idea of contrastive learning; you can't only say what should be close, you should also say what needs to be far. A good embedding is one where the right partner is closer than the wrong ones.

Preparation...

Take a batch of N matching pairs, Encode all N images and all N captions, normalize every vector to unit length, and compute every image-caption similarity. NxN matrix as a result.

The diagonal of this matrix holds the positives (or what pairs are "true"), everything off is a negative. Each caption is a wrong answer for every other image in the batch. Now we have a clear goal, make every row and column peak on the diagonal.

How do we translate this into a loss function?

We can say this is now a classification problem, "which of these N captions belongs to this image?" The standard loss for this is softmax cross-entropy:

\mathcal{L}_i = -\log \frac{\exp(\mathbf{u}_i^\top \mathbf{v}i / \tau)}{\sum{j=1}^{N} \exp(\mathbf{u}_i^\top \mathbf{v}_j / \tau)}

where $u$ are the image embeddings, $v$ are the text embeddings. (both unit vectors, so the dot product is the cosine similarity), and $\tau$ is the temperature. Average it over the rows, do the same over the columns (text => image), and you have the loss used by CLIP.

The numerator wants the true pair to be similar. The denominator wants it to be more similar than everything else. Only the relative order matters, now how big the numbers are, and that's exactly what prevents the collapse I talked about before.

What does the gradient do?

The gradient with respect to the image embedding $u_i$ tells the whols story:

\frac{\partial \mathcal{L}_i}{\partial \mathbf{u}i} = \frac{1}{\tau}\Big(\sum_j p{ij},\mathbf{v}_j ;-; \mathbf{v}_i\Big)

with $p{ij}$ being the softmax probabilities it is saying:

Pull towards its true partner $v_i$
Push away from a weighted average of all the captions, weighted by how much the model currently confuses them with the right one

When the right answer wins clearly, the gradient goes to zero. The loss is satisfied as soon as the ranking is right.

Temperature

$\tau$ decides how big a similarity gap counts as winning. Small $\tau$ punishes small misses hard, too small and training becomes unstable. Large $\tau$ and every negative gets some weight, less discriminative embedding.

You could also make $\tau$ learnable such as in CLIP.

Why normalize?

Without it, the model has a cheap way out: make the vectors longer. Longer vectors mean bigger dot products and a sharper softmax, without actually "learning".

Sample Code

import torch
import torch.nn.functional as F

def clip_loss(img_emb, text_emb, tau=0.07):
		u = F.normalize(img_emb, dim=-1) # unit vector
		v = F.normalize(text_emb, dim=-1) # unit vector
		logits = u @ v.T / tau # similarity matrix
		target = torch.arange(len(u), device=u.device) # "positives" on diagonal
		return (
				F.cross_entropy(logits, target) + # image => text
				F.cross_entropy(logits.T, target) # text => image
			) / 2

Extended Kalman Filters, intuitively

2026-08-06T00:00:00Z

I keep coming back to the Extended Kalman Filter (EKF) every time I touch state estimation on a drone or a rover. It's one of those algorithms that looks like alphabet soup the first time you read it, but is actually a pretty simple idea wearing a trench coat of linear algebra.

The problem

You have a robot. It has some internal state $x$ ; position, velocity, orientation, whatever you care about. You never get to observe $x$ directly. Instead you get two unreliable sources of information:

a motion model that predicts how $x$ evolves over time, and
a handful of sensors that give you noisy, partial glimpses of $x$ .

Both are wrong in known, statistical ways. The whole game is combining "my model says this" with "my sensor says that" in a way that's weighted by how much you trust each one at that particular instant.

The linear case first

If the world were linear, this is just the plain Kalman filter. The state evolves as

x_k = F x_{k-1} + B u_{k-1} + w_{k-1}

where $F$ is the state transition matrix, $u$ is a control input, and $w \sim \mathcal{N}(0, Q)$ is process noise. Measurements look like

z_k = H x_k + v_k

with $v \sim \mathcal{N}(0, R)$ observation noise. Two matrices, $Q$ and $R$ , encode "how much do I trust the model" vs "how much do I trust the sensor." Tuning a Kalman filter is, 90% of the time, just tuning $Q$ and $R$ until the estimate stops lying to you.

Why "extended"

Almost nothing interesting is linear. A drone's orientation dynamics, a wheel odometry model with a heading angle, a range-bearing sensor, these are all nonlinear functions of the state. So instead of $F$ and $H$ being fixed matrices, we have general functions:

x_k = f(x_{k-1}, u_{k-1}) + w_{k-1}

z_k = h(x_k) + v_k

The EKF's whole trick is: linearize $f$ and $h$ around the current estimate, every single step, using their Jacobians:

F_k = \left.\frac{\partial f}{\partial x}\right|_{\hat{x}_{k-1}}, \qquad H_k = \left.\frac{\partial h}{\partial x}\right|_{\hat{x}_k^-}

You still propagate the actual nonlinear $f$ and $h$ to get your best-guess state. But when it's time to propagate uncertainty (the covariance $P$ ), you pretend the world is locally linear and use $F_k$ / $H_k$ in the exact same covariance equations as the plain Kalman filter. It's a first-order Taylor approximation, re-computed at every timestep, and it's good enough for a shocking number of real robots.

The five equations

Everything above compresses into five lines. Predict:

\hat{x}_k^- = f(\hat{x}_{k-1}, u_{k-1})

P_k^- = F_k P_{k-1} F_k^\top + Q

Update:

K_k = P_k^- H_k^\top \left(H_k P_k^- H_k^\top + R\right)^{-1}

\hat{x}_k = \hat{x}_k^- + K_k \left(z_k - h(\hat{x}_k^-)\right)

P_k = (I - K_k H_k) P_k^-

$K_k$ is the Kalman gain, and it's doing all the emotional labor here, it's a matrix-valued answer to "how much should I move my estimate toward what the sensor just told me, versus how much should I trust where I already thought I was." When the sensor is noisy relative to the model ( $R$ large), $K_k$ shrinks and updates barely nudge the estimate. When the model is uncertain ( $P_k^-$ large), $K_k$ grows and the sensor gets to speak louder.

A minimal example

Say you're estimating a drone's pitch angle from a gyroscope (integrate to predict) and an accelerometer (noisy absolute measurement). Pseudocode for one loop iteration:

def ekf_step(x, P, gyro_rate, accel_angle, dt, Q, R):
    # predict
    x_pred = x + gyro_rate * dt
    F = 1.0  # d(x_pred)/dx, trivially linear here
    P_pred = F * P * F + Q

    # update
    H = 1.0  # d(h)/dx, also linear for this toy sensor model
    y = accel_angle - x_pred          # innovation
    S = H * P_pred * H + R
    K = P_pred * H / S                # Kalman gain

    x_new = x_pred + K * y
    P_new = (1 - K * H) * P_pred

    return x_new, P_new

Notice this particular example is secretly linear ( $F = H = 1$ ), which is basically a complementary filter with extra bookkeeping. The "extended" part earns its keep once $f$ or $h$ genuinely curve, quaternion kinematics, range-bearing landmarks, wheel-odometry with $\cos\theta$ / $\sin\theta$ terms. That's when the Jacobians stop being trivially $1$ and start being actual matrices you have to derive by hand (or, more realistically, generate symbolically and hope you didn't drop a sign).

Where it breaks

The linearization is only valid locally. If your prediction is badly wrong, or your motion model is highly nonlinear over one timestep, the first-order Taylor expansion stops being a good approximation and the filter can diverge, confidently wrong, which is worse than uncertain. This is the standard segue into unscented Kalman filters (propagate a small set of sigma points through the true nonlinear function instead of linearizing) or particle filters (drop the Gaussian assumption entirely). But for a huge fraction of robotics problems, attitude estimation, SLAM front-ends, sensor fusion on a budget of a few KB of RAM, the EKF's "good enough, cheap, and well understood" tradeoff still wins.

GAE

2026-03-19T00:00:00Z

Bias vs. Variance

(When talking about Reinforcement Learning)

The $\lambda$ parameter is like a dial to balance bias and variance. This determines how quickly and stably the agent learns.

High variance ( $\lambda$ close to 1 ) makes the GAE behave more like Monte Carlo. This means we use the actualy rewards collected to the end of the trajectory. The estimation from GAE is and unbiased of the enviornment. Gradients can be noisier because they depend on a long list of random actions (specially on early stages).

Hypercontent

2022-11-27T00:00:00Z

Lets talk again about aicontent, but now way more in the future.

A time were computational resources are abundant in unimaginable ways, computers capable of simulating whole sections of the universe for research/accumulation purposes are the norm. cameras, scanners, sensors, so small that we can't distinguish them from air particles. data collection has reached it's peak.

Information is no longer measured with the words we are used to, numbers that make sense to humans are no longer capable of signifying the magnitude of everything we are recording.

I want to create a game

2022-07-05T00:00:00Z

So i want to create a 3D game, i'll update this page with some ideas i have.

Brutalist Architecture

32-Bit kinda looking
https://twitter.com/sunset_city_rpg/status/1477468508086849537?s=20
https://twitter.com/DavidKayConrad/status/1480942506061742082?s=20
keywords: psx

Artstyle
https://www.blendswap.com/blend/22459
https://www.blendswap.com/blend/21543
keywords: wireframe, monochromatic, dithering, old macs

What
https://en.wikipedia.org/wiki/Role-playing_video_game

Where
https://godotengine.org/
https://zdoom.org/wiki/SLADE

Misc.
https://github.com/Captain4LK/SoftLK-tools
https://lampysprites.itch.io/pribambase
https://github.com/LibreSprite/Dotto

Colors
https://lospec.com/palette-list

Ideas

have dialog
not an fps, im thinking an rpg but with a twist

Process

05/07 - I got running godot with trencbroom because i dont like 3d moddelling of levels

The end of a civilization, caused by the start

2022-06-22T00:00:00Z

-- Planet A -- Day 1 Log --

-> I arrived to this planet, today is my first day here.

-> I came to this steep canyon, while getting out of my ship I noticed (despite their big size), huge crystal formations. Strangely enough, they didn't shine, as if they needed something to light them up.

-> Got near one big green crystal, it was round but had sharp corners, as if it didn't want anyone close. Broke a little piece, took a picture and got inside my ship.

-- Planet A -- Day 2 Log --

-> While resting in my ship (autopilot), I stumbled across this big (and i mean it) mushrooms. What intrigued me was how these covered a whole snow mountain, even more than the snow. I've never seen something like that, there has to be a reason. Were they there because of the oxygen? I didn't see them below, there had to be a reason. Maybe the sunlight was better?

-> I didn't step out of my ship because the mountain was not as "safe" as i wanted. I didn't want an avalanche to form and freeze me to death. So i just went ahead back to rest, hoping those mushrooms were, well, mushrooms. Configured my autopilot to lead me to a safer place.

-- Planet A -- Day 3 Log --

-> This was intersting, it seems like my autopilot really has been in this planet before lol. While in the foot of the mountain, were less snow was noticeable (but still trees), on top of them, were remains of an ancient civilization, hiding behind leaves and vines. There it was what it seemed like a house, but for someone twice my size, my ship's size. This group of habitants were not there, and somehow seemed like were not coming back? Altough what really amazed me was how despite their size, they decided to settle on top of trees.

-> What could be so dangerous for the "big people", that they decided to live away from the floor?. I wasn't sure, but what gave me chills thinking how they were not on their "safe place" anymore. Did the danger from below reached their cities on top of the trees? There was no way of knowing. Despite this, I decided to investigate more, only to find the innofencive mushrooms from the mountain, just in a drastically less quantity.

-> I had too much in my mind. I felt my whole brain falling down the rabbit hole, was i close to uncovering something?

-> "The end of a civilization, caused by the start of another", sounded like a good title for this planet's journey. Talking about the planet, i also have not named it, i need to set up a reminder or something to brainstorm ideas for it.

-> I was decided to find the reason (if there was any), so taking my lucky shot, I just turned ON my autopilot again, and went to rest my mind for some time. If the ship brought me into this, then it should help me get out.

-- Planet A -- Day 4 Log --

-> I heard alarms, snow was all around the ship. Avalanche, the same thing I was just trying to avoid, had happened. But why? I realized we were back on the snow mountain, why did my ship brought me back, and much more worse, with a snow storm happening and seemingly destroying the mountain itself.

-> To my surprise, it ended quickly, but to my bigger surprise, the iconic mountain mushrooms were not there anymore, were they buried by all this snow/glacier chaos?

-> I decided to get out of my ship to see this, if something was happening on the planet, it must have caused this avalanche.

-> Equipped my suit and got out.

-> I can tell you this, the difference of mushrooms that i found buried versus the ones that were before was huge. Do mushrooms evaporate at low temperature? Acid snow? What could even make sense, all in this planet was new for me.

-> I knew something was up, but in my mind, i couldn't figure out what, there was something i was not seeing. Civilizations crumbling, mountains falling down, mushrooms dissapearing, caves full of colorful round crystals (altough I think that has nothing to do).

-> There was a vague line among this things that i couldn't see.

-> Strangely enough, shadows started to appear, one by one, different sizes, but all of them were getting bigger at the same rate. I just had to look up. There they were, the mushrooms were flying, reaching into space. They seemed to be joining, mixing, blending? All these among themselves. I've never seen them do that, were they really mushrooms?

-> It was like some kind of hive-consciousness, gathering all mushrooms into something bigger, while at the same time, reuniting with the others coming up from other planets.

-> All with one unknown specific destination, galaxies and galaxies away.

AI-Generated Content

2022-06-16T00:00:00Z

Even today, 2022, AI-generated content is slowly starting to break into mainstream culture. Lets take Dalle as an example, people are going crazy by the posibility of entering random word sequences that turn into an image.

Who would have thought that a court sketch with godzilla would have been a thing?

https://twitter.com/tylerzanca/status/1534894404523069440?s=20&t=BtIKHw8xez7HASpCHKeQHg

Imagine the sheer posibilities of content creation in the future.

Fans wouldn't have had to ask Warner Bros for the Znyder Cut, just feed the idea into an AI and you are ready.

I'm talking generating full-length movies just by writing a few words into a prompt and a 10 minute wait.

Why should i stop at movies? Music, Art, Radio/Podcast, Books, Video Games. Content generated to user's desire, just in a few minutes.

Final Thoughts:

Are companies going to still produce movies in a future?
Are we even going to need actors anymore when an AI could generate millions of different faces, personalities, jokes, accents wihtout asking for a penny. (Well maybe just an electricity bill)
Surveillance that watches every single action that we make, and that when asked, will generate content based on it. How? Let's say you live with your sister,