• 

  Cultivate a slime by feeding it examples, observing its response, and providing corrective feedback.

• 

  Inspect how each prediction is calculated from word and phrase memories, shared bias, weighted mixing, and activation.

• 

  Analyze each slime’s learning state, memory balance, and learned word-weight distribution.

• 

  Discover machine-learning concepts through experiments and connect each concept to the slime’s current calculations.

• 

  Review daily learning patterns and record observations, hypotheses, and experimental notes.

Colorless Slime

Inspiration

I wanted to understand how AI systems actually learn—not just how to use them.

Many AI applications reveal only the final answer, leaving the learning process hidden inside a black box. Reading about neural networks helped, but I found myself wanting something I could actually cultivate, observe, and experiment with.

Instead of building another chatbot, I decided to build a tiny AI whose learning process could remain visible. If I could watch its predictions and learning updates, and inspect how its internal state changed, perhaps machine learning would become something to explore rather than simply accept.

That idea became Colorless Slime.

---

What it does

Colorless Slime is an interactive AI cultivation laboratory.

Users cultivate an intentionally minimal, transparent learning model by feeding it examples. They can observe its predictions and learning updates, inspect the calculations behind them through a microscope interface, and gradually develop an intuition for machine learning.

Users can also record observations and hypotheses, replay training sets through reusable food bundles, and compare slimes with different learning histories.

The project intentionally favors transparency over capability.

---

How I built it

Colorless Slime is built with React and TypeScript. It can run as a web application or locally through a lightweight Windows host.

The current learning model is deliberately simple. It uses word-level and phrase-level memory, weighted sums, a shared bias, a tanh activation function, and gradient-based updates from user feedback. The model produces a single continuous reaction between avoidance and approach.

Rather than hiding this internal state, the microscope interface presents a readable summary first and allows users to expand detailed calculations and structured logs whenever they want to investigate further.

---

Challenges

The biggest challenge was balancing educational value with usability.

Displaying every internal calculation at once quickly became overwhelming, while hiding too much defeated the purpose of the project. I redesigned the interface several times so users could understand the result at a glance, then inspect weights, bias, representation spaces, activation, and learning updates only when they wanted more detail.

Another challenge was keeping the model simple enough to understand without making the experience feel trivial. I introduced separate word-level and phrase-level memory spaces so users could experiment with the trade-off between generalization and memorization while keeping the entire learning process observable.

---

What I learned

Building Colorless Slime taught me far more about machine learning than simply reading about it.

Designing each part of the learning loop forced me to understand weights, bias, weighted sums, activation functions, prediction error, learning rates, and gradient-based updates from first principles.

Experimenting with the model also made abstract learning behaviors easier to recognize. I could observe how shared word memories enable generalization, how phrase-specific memories support memorization, how new learning can interfere with earlier learning, and how different training histories produce different responses to the same input.

Most importantly, the project showed me how much educational value transparency can provide.

---

Future

This is only the beginning.

I want Colorless Slime to grow alongside my own understanding of AI.

Future versions could expand beyond the current single-axis model into higher-dimensional representations, hidden layers, reinforcement learning, and richer forms of experimentation—all while keeping the learning process observable.

Rather than accepting that greater capability must mean less transparency, my long-term goal is to explore how increasingly capable AI systems can remain understandable while still inviting observation, experimentation, and learning.

Built With

• c#
• codex
• next.js
• openai
• react
• typescript
• vite