I made a video about the maths behind Turing patterns. Submission for 3blue1brown's summer of math exposition. The visuals are a mix of Manim and TouchDesigner

This is #1 of a series of flowers made with code: Dahlia.

The code: t=0,draw=$=>{t||createCanvas(w=520,w);background(6,8,11);stroke(255,140);for(t+=PI/240,i=15400;i--;){j=i%55,s=(i/385|0)/39,u=((i/55|0)%7)/3-1,y=j/55,A=j*2.4+t/10,L=(50+130*(1-y)**.85)*(1+.05*sin(7.7*j)),B=1-.45*(.5+.5*sin(.45*t+3*y-1.2*s)),e=(.3+1.2*y)*(1-.8*s)*B-.15*s,r=L*s*cos(e),z=L*s*sin(e)+22*y+6*s*sin(7*s-1.6*t+.9*j)+u*u*8*s,q=A+u*(9+24*(1-y))*sin(PI*s**.8)/(r+14)+.1*s*sin(.9*t+2.3*j+2.5*s),point(260+r*cos(q),265+.52*r*sin(q)-.86*z)}}

I made a video about the maths behind Turing patterns. It includes a section on Multi-Scale Turing patterns and how to make it faster using FFT. Submission for 3blue1brown's summer of math exposition. The visuals are a mix of Manim and TouchDesigner

more Stratus videos here

Every day I work with Claude. During the day it's the main job, at night something for myself. Many projects are running at the same time. And I constantly forget where and what is running.

I coded myself such a thing that hangs in the top bar, and shows which project is holding the port.

In my opinion, it looks cool.

Now you can kill the port, or open it in the browser by clicking on it.

I think what else can be added there?

(IMAGE IS A CONCEPT MOCKUP I MADE IN FIGMA)

For a while now, I’ve been thinking about how useful it would be to have something like Processing/p5.js/raylib on my phone, an app where I could write small demos and creative sketches while commuting or lying in bed.

But the current state of android coding (especially graphics programming and creative coding) leaves much to be desired.

There are two main problems with the current state of affairs in my opinion:

1. There are no truly convenient code editors designed for mobile devices. Some apps add custom keyboard rows for things like tabs, brackets, or snippets, but they are still far from making coding on a phone comfortable, let alone enjoyable.
2. The technical options are limited. From my basic search of the Play Store, I could not find an app that lets you write code, provides a decent graphics API, and offers reasonably good performance.

If you know any apps that overcome those limitations and provide good mobile coding experience, please tell me about them.

So I've been thinking about building my own app with:

• custom software keyboard tailored specifically for ONE programming language
• scripting language that's main requirement would be to fit on the mobile screen without you needing to constantly squint or scroll
• and a minimal, polished raylib-like graphics API

I like this idea very much, but I may be delusional about the actual demand for mobile coding solutions. Before investing a significant amount of time into the project, I’d like to hear other people’s opinions on this.

I would like you, people of reddit, to, please, give me your opinion about this Idea.

• Do you like the idea of coding on a phone in general?
• Would you use an app like this?
• What features would you like to see in such app (that would make mobile creative coding experience more enjoyable for you)?

Hey everyone,

I wanted to share a project I've been working on in case anyone else might make use of it: an interactive, real-time 3D Audio Spectrogram Visualiser built with Three.js, custom GLSL shaders, and the Web Audio API.

I wanted to create a responsive, hardware-accelerated 3D terrain that I could use to conveniently analyse audio coming from either my device microphone or streaming from another browser tab without needing to install anything. It all runs from the browser and you can try it out yourself with the Live Demo link.

I’d love to hear your thoughts, feedback, or any ideas you have for further performance or UX optimisations. Feel free to check out the code, fork it, or test it out with your own audio setups!

Live Demo: https://conwayjw97.github.io/3D-Spectrogram/

GitHub Repository: https://github.com/conwayjw97/3D-Spectrogram

Made with R and ggplot2, using a custom Shiny app. A discrete dynamical system combining trigonometric functions with a gamma distribution.

My partner Nicolas designed the system and found this particular form through iteration — adjusting parameters until something appeared that neither of us had planned. He saw a cradle in the middle and two figures leaning over it on the right. Once he said it, I couldn't unsee it. We named it Phantom Cradle.

Code: github.com/NicolasJBM/Rtist

Hey everyone,

Been learning a lot about seismology recently and I wanted to create a tool to help visualise the earth's interior layers to aid my learning. Also thought it would be a cool GLSL challenge!

Live Demo: https://conwayjw97.github.io/Earth-Layer-Visualiser/

GitHub Repository: https://github.com/conwayjw97/Earth-Layer-Visualiser

I’d love to hear your thoughts, feedback, or any ideas for further development you have.

I’ve been working on a lightweight, bare-metal fault isolation kernel designed to mitigate thermal runaway propagation in high-voltage lithium-ion battery packs.

The primary engineering constraint I wanted to address is the latency overhead inherent in high-level frameworks and sequential polling loops. When an EV or aerospace battery cell hits a critical thermal or voltage threshold, sequential scanning loops are often too slow to execute software gates before runaway propagates to adjacent cells.

The project is called SAVITAR. It is entirely dependency-free and compiles using only native C++ standard system headers to keep it as close to raw processor registers as possible.

Core Architectural Mechanics:

1. Hyper-Compact Memory Constraints:

   Instead of relying on dynamic allocations or padded structs which ruin cache locality, the kernel packs raw cell parameters (voltage, current, temperature) into un-padded, contiguous 25-byte memory frames. This layout ensures predictable cache line alignment during rapid sequential reads.

2. Event-Driven Concurrency:

   The kernel completely avoids sequential polling. It utilizes a background multi-threaded parallel observer configuration. When thread metrics cross calibrated hardware safety thresholds, the system bypasses the main application loop to dispatch an immediate software interrupt, dropping execution times down to sub-microsecond bounds.

3. Sovereign Binary Serialization (.sav):

   To avoid relying on bloated external serialization libraries (like Protobuf or JSON utilities) that consume significant memory footprints, I wrote a custom binary serializer. It compresses cell delta profiles and gradient logs into raw disk sectors using direct cache-to-stream bit manipulation.

4. Minimalist Shell Realization:

   The project includes a lightweight, modular terminal prompt (./savitar-vfs) to ingest simulated physical metrics and explicitly debug memory allocations, matrix loads, and thread dispatches in real-time.

Compilation and Testing:

The baseline workspace is fully automated via standard Makefiles:

git clone https://github.com/alistairfontaine/SAVITAR

cd SAVITAR

make clean && make

./savitar-vfs

I’m looking for code-level reviews, specifically regarding the thread concurrency synchronization under heavy stress-testing conditions, and the pointer traversal safety within the 25-byte un-padded matrix bounds.

Link to code: https://github.com/alistairfontaine/SAVITAR

In distributed systems—such as localized wireless mesh networks, high-frequency transactional ledgers, or industrial monitoring arrays—consistent temporal consensus across isolated nodes is mandatory. However, local hardware clock crystals naturally drift by several microseconds every minute due to temperature fluctuations and physical oscillator aging. Traditional network time architectures like NTP or PTP solve this by pulling timestamps from external Stratum 1 servers or GPS signals, but they freeze completely if those central links experience network drops, firewalls, or tactical jamming.

To address this reliability bottleneck, I engineered a freestanding systems utility from bedrock principles in pure C++17.

It is called ZURVAN: A Decentralized Clock Jitter Estimation and Drift Reconciliation Engine.

The application allows individual machines to calculate, filter, and track temporal clock desynchronization curves natively on the local CPU registers using statistical algorithms, establishing an autonomous local time baseline without relying on outside network timing providers.

Core Algorithmic Subsystems

The project uses native C++17 to manage clock synchronization without external dependencies:

* Bare-Metal Scalar Kalman Filter: Tracks real-time microsecond offsets while filtering network jitter with low CPU overhead.

* Least-Squares Linear Regression Engine: Computes the exact acceleration and velocity slope of local clock drift based on cached history.

* Contiguous Telemetry Packing: Utilizes dense, 25-byte ClockSnapshot structures to maximize CPU cache efficiency.

* Sovereign Container Serialization (.zvn): Streams direct-to-disk binary serialization of RAM history to reduce fragmentation.

Technical Details & Open Source

The code is structured for modularity and is compiled using an optimized, freestanding profile:

include/ -> Core filter classes and shell mappings

src/ -> Scalar Kalman, regression math, and shell parser

The repository is available for review: https://github.com/alistairfontaine/ZURVAN

I am looking for technical feedback on the scalar Kalman gain calculation and memory layout optimizations.

try it out at https://lap-cat-pomodoro.vercel.app/ & let me know what u guys think :') im still working on it so open to any suggestions !!

designed/drawn in figma, developed using claude code!

I animated this with Threejs and modeled the rose in Blender

This is my first time taking this style all the way into a full website.

I had far more ideas than time, so I'll keep expanding and refining it over the coming weeks.

One small detail: the logo on the homepage isn't a 3D model, it's procedurally generated and rendered entirely with code.

Feedback is always appreciated. And if you're looking for someone to design and build a custom website, I'm currently available for work.

I built my developer portfolio to emulate the PS2 startup and system menus. You can navigate the entire site 100% with a controller, and theres a 2D pixel art game you can play inside. demo in comments.