#Started thinking more about dimensions and stuff

##All I did was checking the measurements so I will attach a photo of the same acrylic panel

Devlog #1: From “just project it” to building my own projector

I wanted a Raspberry Pi display that doesn’t look like a normal monitor: an image that floats on an acrylic board. My first plan was the obvious one: point a projector down at an 880 x 300 mm acrylic board and call it a day.

That fell apart fast. Clear acrylic doesn’t show a projected image because the light goes straight through, so I’d need frosted or white acrylic. The board’s shape was also a problem. 880 x 300 is about 2.9:1, while projectors output 16:9, so around 40% of the pixels would land off the board. And a normal projector needs to sit about a meter above it.

Pivot: Pepper’s ghost

So I switched to a Pepper’s ghost setup: a hidden screen above, and clear acrylic at 45° that reflects it toward you, so the image looks like it’s floating. Much cooler. The catch is that the floating image is exactly the size of the screen, so filling the board meant a huge, heavy, expensive monitor hanging overhead. Not happening on a Hack Club budget.

Building my own projector

What I actually wanted was to take a small screen and magnify it. I looked at a Fresnel lens over a screen, but the physics doesn’t work: a magnifier only makes the screen look bigger from one spot. It can’t put a sharp image onto a surface. The only thing that does that is a projector. So instead of buying one, I’m building one from parts:

• 5.5” 2K LCD panel + HDMI driver board
• 100W LED
• A pair of Fresnel lenses
• A multi-element projection lens

The Pi just sees it as an HDMI monitor.

The rest of the system

• OS: Arch Linux ARM. Hard mode, but I’ll actually understand the whole system.
• Input: a global-shutter camera running MediaPipe hand tracking, so the display works like a touchscreen without a touch sensor. I skipped YOLO; it’s object detection and overkill for tracking fingertips.
• Two Pis: Pi A runs the display and UI, and Pi B only does camera and hand tracking, then sends fingertip positions to Pi A. Splitting by workload means neither one stutters.
• Failover: planned for later. If Pi A dies, Pi B takes over the whole system.

The budget fight

The hardest part so far was the budget. Hack Club grants are capped at $600 and you only get one submission, so everything had to fit now. My first parts list came to $661, before shipping. I trimmed it line by line:

• Storage: microSD instead of NVMe for now.
• Keyboard projector: I’ll fund the second projector myself.
• Lens: kept the good multi-element one. That’s the one place I refused to cut, because it decides whether the image looks sharp or muddy.
• Frame: 3D-printed brackets instead of an aluminum extrusion frame.

Then I checked every link and price, and found the Pi 5 had gotten a lot more expensive this year because of the RAM shortage. More rebalancing, but the final list fits.

Next: CAD for the ghost box.

Devlog: From bigram to building my own tokenizer

Last time I had a bigram model trained on The Wizard of Oz that mostly made gibberish. Since then ARIA has gone through three versions, and I ended up writing most of the pipeline from scratch.

ARIA-01 / 02: a real transformer

I replaced the bigram with a character-level GPT: 8 layers, 512-dim embeddings, 8 attention heads, 256-character context, trained on web text on my RTX 5060 Ti.

• Bumped block_size from 8 to 256 so the model can actually see whole sentences
• Added bf16 autocast, which cut VRAM use roughly in half
• Found out the hard way that when VRAM fills up, Windows quietly spills into system RAM and training gets about 20x slower. Batch 128 was taking 6 to 9 seconds per step; batch 64 was 0.35 seconds
• Fixed a bunch of bugs along the way, like my argparse -batch_size flag secretly setting block_size, and eval running 500 batches every 250 steps

Final pretraining loss was about 1.30 per character, and it started writing real English sentences (that didn’t make sense yet).

Teaching it to chat

The base model only continues text, so I fine-tuned it on Alpaca formatted as User: ... / ARIA: ... conversations, with a lower learning rate so it wouldn’t forget English. Loss went down to about 0.91.

Then I had to fix the chat script: wrapping prompts in the right format, cutting replies at the end of a turn, and adding temperature + top-k sampling so it stopped picking random characters. First real reply to “How do you make a cookie?”:

You make a cookie are both a cookie.

Grammatically broken, but it’s an actual answer, in the right place, that stops on its own. The pipeline works.

Writing my own BPE tokenizer

The biggest limit was being character-level: the model wasted most of its capacity on spelling, and 256 characters isn’t much context. So I wrote a byte-level BPE tokenizer from scratch instead of using a library:

• get_stats and merge to find and merge the most common pairs
• a training loop with stop conditions (no more merging pairs that only appear once)
• encode / decode with a round-trip test, plus save/load for the merges
• GPT-2 style regex pre-splitting so tokens can’t cross word boundaries (before this, I was getting tokens like "is to " and "00 MPa ")
• a cache in encode that made it about 2.3x faster on small text and much more on big files

Trained on about 1MB of educational text plus chat data, with 2048 tokens. It learned real word pieces like " economic", " School" and "rying", and gets about 3x compression. Since it’s byte-level, there are no unknown characters anymore, so Korean works too.

ARIA-03

I encoded 500MB of fineweb-edu into 169.6M tokens, saved as uint16 binary and loaded with np.memmap. Then I rewrote the model:

• Fused attention with F.scaled_dot_product_attention instead of 8 separate heads, about 3x faster per step
• Pre-norm blocks and GELU
• Weight tying between the embedding and output layer
• Warmup + cosine learning-rate schedule
• state_dict checkpoints with optimizer state and step count, so a crash doesn’t wipe a run

Test run: loss started at 7.71 (right at ln(2048), which is what random guessing should give) and reached 4.27 after 1000 steps, with train and test matching the whole time.

Next

• Full 30,000-step pretraining run (about 3 passes over the data)
• Chat fine-tune on the new tokenizer
• Later: tool use, like search through the Naver Search API, a separate vision-based security AI for home cameras, and an agent that writes and uploads Arduino code

Edith Devlog

Spent today taking Edith from a bare Pico 2 schematic to a fully routed PCB with zero DRC errors. Feels good. Got the core sensing stack wired up: an I2S mic, a speaker amp, a small OLED for status, a status LED, and a reflective IR sensor so the glasses boot up when you actually put them on. Also added a camera (ArduCAM Mini OV2640) over SPI, and partway through swapped the plain Pico 2 for a Pico 2 W so I could get Bluetooth/WiFi without giving up a single GPIO — the wireless chip talks to the RP2350 internally, never touches the exposed pins. For power, I’m going with a LiPo + an external TP4056 charging module instead of building charging circuitry into the main board, feeding in through VSYS so the Pico’s own USB-C stays free for programming. Honestly the most useful part of today wasn’t the designing, it was catching my own mistakes before they turned into a real, fabricated mistake. Caught a header that looked wired but wasn’t, a resistor that was 1000x too big (330k instead of 330 ohms — RIP my IR LED if I hadn’t caught that), an amp that would’ve gone dead silent the second it switched off USB power, and a decoupling cap I forgot entirely and then placed on the wrong side of the board. Board’s a full prototype size right now, nowhere near small enough to fit in an actual temple — that’s the next phase, probably splitting it across smaller boards connected by flex cable once I know the electronics actually work. Next up: get this fabbed, then start on firmware. 

Kind of starting to take form…….

I am making a bigram language model first, and I am making it a lot better than I thought. I am using the wizard of oz to train it, but it shows mostly giberish but it is really good. Also I did more recap on the functions in PyTorch so I could use it in other projects too!

ADDING MORE FUNCTIONS AND LEARNING DOT PRODUCT

This is going to be a short one, since all I did was get used to the pytorch library, and all the math. Also, the dot product and the matrix mult was not that bad! I did all my functions and all that I need for the llm. The importants are softmax, concat and stuff like this. I really like where this project is going and where it is taking me! SO STAY TUNED IN!

A new project, New lab

This is a whole new project GUYS! This project is called ARIA. ARIA can hear your voice, run it through an custom, built from scratch LLM, and talk it out. All I did today was only math that would make me understand LLMs better and also code a teeny tiney bit, but I still like it! Follow allow my journey! Also this is a lab of mine that I made by myself! So my really good projects are probably going to be here! (Some other projects that are really good MIGHT not be here so check my other projects to! (Sorry that there are incomplete projects))

Ocean Board

August 17, 2026 · 11 hours, one sitting

I finished Ocean Board today.

Ocean Board is a custom devboard I designed around the RP2040 — my own take on what a Pico-style board should look like, built for the stuff I actually want to do with it instead of whatever the off-the-shelf version assumes. I sat down and just didn’t stop until it was done. Eleven hours later, it’s real.

Why I built this

I wanted a board that was mine — something I understood down to every trace and part choice, not just another Pico clone I bought off a shelf. RP2040s are everywhere, but building my own version meant I got to decide exactly what went on it and why.

What’s actually on it

• RP2040 — the chip doing all the thinking
• W25Q128 — 16MB of external flash, because I didn’t want to be tight on storage later
• TLV62568 buck converter — keeping power clean and regulated
• Two 16-pin GPIO headers (left and right) so I’ve got breakout room to actually build things on top of this
• BOOTSEL and RESET buttons — small, but you don’t appreciate them until you’re stuck without one
• Micro-USB for power and programming
• The usual supporting cast of caps, an inductor, and a couple of precision resistors making sure everything plays nice

The 11 hours

Honestly it was one of those sessions where I sat down expecting to make a dent and just… didn’t stop. Nailing down the BOM, double-checking footprints, assembly, and then the moment that actually matters — powering it on for the first time and finding out if eleven hours of work was going to boot or smoke.

(This is the part I want you to fill in — what actually went wrong, what almost didn’t work, the moment it powered on, anything you had to re-solder or debug. That’s the stuff that makes a devlog feel real instead of a spec sheet.)

What’s next

• Flash something basic on it — blink an LED, get USB serial talking
• Push the power regulation a bit to see how it holds up under load
• Write up the GPIO pinout properly so I’m not guessing later
• Think about a v2 — enclosure, more flash, maybe a different connector

Notes to self

Eleven hours is a long single sitting — next time I should actually track where the time goes. Also already have a BOM scaled up for a 10-board batch if I ever want to build more than one of these.

More devlogs coming as I start actually building on top of this thing.

What is up guys I Finally finished this!

I changed the whole design of the hackpad and I made everything from scratch and made the 3d design again! And I am going to ship it TODAY! This means a lot since this is the first every hardware project in hackclub stardance, so I will show you when the HACKPAD is finished! this is the image of the 3d design!

Dycosystem — Devlog

What’s up guys! This one was mostly math, not code.

Got the Neural_network class doing an actual feedforward pass now, but honestly most of my time this session wasn’t spent typing, it was spent on a whiteboard (well, my head) trying to actually understand the math before I wrote a single line.

The part that took forever

Matrix multiplication only works if the columns of the first matrix match the rows of the second, and figuring out WHY that has to be true, not just memorizing it, is what ate most of my time. Once that clicked, the actual network made a lot more sense: weights between input and hidden layer have to be shaped (hidden_nodes, input_nodes) specifically so the multiplication lines up correctly, same for hidden to output. It’s not arbitrary, the shape IS the math.

What actually got built

• Weight matrices between input→hidden and hidden→output, plus bias matrices for each layer
• A sigmoid function to squash the raw weighted sums into something usable
• feedforward(input): turn the input into a matrix, multiply by weights, add bias, sigmoid, repeat for the next layer, turn the result back into a normal array

Fed it [1, 0] and got a real guess back out. Random weights so the guess means nothing yet, but the math pipeline actually works end to end now, and I understand every step of it instead of just copying it.

Small but important fix

Weights used to randomize as integers 0-9 which is wrong for a neural network, changed it to floats between -1 and 1, which is what weights are actually supposed to start as.

What’s left

train() exists but does nothing yet. That’s the next math rabbit hole, figuring out how to actually adjust these weights based on how wrong the guess was.

Slower progress than usual but way more understanding behind it. Thanks for reading, see you next devlog!

(I am posting a picture of my dog since I have nothing to post a picture of, this is probably the devlog with the most pictures!)

Dycosystem — Devlog

What’s up guys! Big one this time — the network can actually think now.

Wired the Neural_network class up to a real feedforward pass. Before this it was just remembering how many nodes it had — now it actually takes an input and produces a guess.

Feedforward is alive

• Added weight matrices between input→hidden and hidden→output, plus bias matrices for each layer, all randomized on creation
• Added a sigmoid activation function so the outputs squash into a usable range instead of just raw numbers
• feedforward(input) now does the full pass: multiply by weights, add the bias, squash through sigmoid, twice (once per layer), and hands back a real guess

Ran it with a plain input array [1, 0] and got an actual output back. First time this thing has done anything resembling thinking, even if the “thinking” is currently just random weights.

Matrix got two new helpers

• Matrix.make_from_array() turns a plain array into a column matrix
• make_to_array() turns a matrix back into a plain array

Needed both since the network has to convert real inputs into matrix form to do the math, then convert the result back into something normal code can use.

Also fixed something small

randomize_matrix() used to fill values with random integers 0-9, which makes no sense for neural network weights. Changed it to random floats between -1 and 1, which is the actual range weights should start in.

What’s still missing

train() exists but it’s empty right now — the network can guess, it just can’t learn from being wrong yet. That’s next.

Genuinely exciting one, this is the first time the neural network side of the project has produced output instead of just being scaffolding. Thanks for reading, see you in the next one!

Dycosystem — Devlog

What’s up guys! Small but satisfying update.

I went back through my Matrix class and actually fixed a bug that was sitting in the matrix multiplication code — I was resetting my running sum inside the innermost loop instead of before it, so it was only ever keeping the last multiplication instead of adding them all up. Classic off-by-scope mistake.

Fixed: matrix multiplication

• Moved the sum reset outside the loop so it actually accumulates properly
• Pulled it out of scalar_mult and made it its own static matrix_mult function, since cramming two different operations into one method never made much sense

New: map and map_index

• map(fx) runs a function over every value in the matrix
• map_index(fx) does the same but also passes in the row/column, so the function can behave differently depending on position
• This is going to matter a lot once I get to activation functions — applying something like sigmoid to every node is exactly what map is for

New: print_table

• Small helper so I stop retyping console.table(this.matrix_values) everywhere

Why this matters

Feels like boring plumbing work, but this is the stuff the whole neural network is going to be built on top of. I’d rather get it solid now than debug it later once there’s an actual brain depending on it.

Thanks for reading, see you in the next one!

Dycosystem — Devlog

What’s up guys! Quick but important update this time.

I leveled up from just a single perceptron to actually starting a real multi-layer neural network. First thing I had to do for that was build my own Matrix class, since it turns out neural networks are basically just matrix math wearing a trench coat — the weights, the inputs, the outputs, all matrices, and “guessing” is really just multiplying them together.

Matrix class

So I wrote one from scratch. It can zero itself out, randomize itself, transpose, multiply by a number or by another matrix, and add stuff to itself. Not the most exciting thing to build, but literally every neural network sits on top of this, so I wanted to actually get it instead of just grabbing a library and moving on.

The actual network

I also started the real Neural_network class, but honestly it’s not doing much yet — right now it just remembers how many input, hidden, and output nodes it has. No actual thinking happening in there yet. Next up is hooking the Matrix class into it so it can take inputs and spit out a real guess, and after that, actually learn from being wrong.

Also reorganized everything

Now that I’ve got two real tracks going I split the project up — Genetic_Algorithms/ for the ecosystem sim, and NeuralNetwork/ for all this neuroevolution groundwork.

Slow progress this time, but it’s the kind of slow that matters — I’d rather actually understand the math than fake my way through it. Thanks for reading, see you in the next one!

Necklace FPV Drone - Devlog

A from-scratch FPV drone, small enough to wear on a necklace with a magnetic quick-release mount. FPV camera now, AI vision later. Building it in phases so I actually get it flying before piling on features.

Goals

• Custom frame, designed myself in Fusion 360 (no off-the-shelf kit)
• Wearable - clips onto a necklace with a strong magnet
• Analog FPV camera, mounted so it’s easy to swap later
• Eventually: onboard AI vision, then full remote steering

Roadmap

• Phase 1 - Fly: motor, FC, props, frame. Just get it in the air.
• Phase 2 - Sense: add the AI vision module (Grove Vision AI V2 + XIAO ESP32S3)
• Phase 3 - Steer: radio, camera/VTX/goggles, battery
• Phase 4 - Wear: magnetic necklace mount, final frame with camera + magnet built in

Phase 1 BOM (flight test only)

Motor: BETAFPV 1103, 15000KV (x4) - 1.5mm shaft, M1.6 mount on 8.5mm pattern
Link: https://betafpv.com/products/1103-brushless-motors

FC: GEPRC TAKER F411-12A-E (1-2S AIO), 25.5x25.5mm M2 mount
Link: https://geprc.com/product/gep-taker-f411-12a-e-12s-aio/

Props: Gemfan 1635-3 40mm Tri-Blade, Clear Blue - 1.5mm shaft
Link: https://wrekd.com/products/gemfan-1635-3-31mm-triblade-1mm-shaft

Frame: Custom, Fusion 360

Full CSV: drone_bom_phase1.csv

Watch out for:

• FC comes with an XT30 power pigtail; the battery I’ll use later is PH2.0 - need to re-terminate
• Prop listing defaults to 1mm shaft - has to be ordered as 1.5mm to fit the motor
• Frame holes need to match both patterns above

Parts scoped for later

Phase 3 - FPV + control:
Caddx Ant camera (16:9 black), BETAFPV M03 VTX (connector compatibility with the camera still unconfirmed), iFlight 1S 300mAh battery, BETAFPV BT2.0 charger, RadioMaster Zorro, goggles TBD

Phase 2 - AI:
Grove Vision AI V2 + XIAO ESP32S3 Sense (both from icbanq), CSI camera for the Vision module not yet picked

Phase 4 - Wearable:
N52 magnets, necklace hardware, PETG-CF for the final frame revision

Notes

• Going with PETG over PLA for the frame - PLA’s too brittle and heat-sensitive for something that crashes and gets worn on the body
• First real test: spin the motors through Betaflight Configurator over USB, props off, before touching a battery or radio
• Keep the necklace magnet away from the FC’s compass for whenever GPS stuff happens

Open questions

• Does the Caddx Ant’s connector actually match the M03 VTX?
• Still sourcing motor, prop, FC, and goggles locally in Korea - everything’s international for now
• CSI camera for the Vision AI module: not picked yet

What’s up guys! Smaller update this time, but an important one…

I reorganized the project into folders first — all the ecosystem stuff now lives in Genetic_Algorithms/, since I’m about to start a second track of the project: Neuroevolution/.That’s right, I started learning how to actually give my creatures brains instead of hardcoded behavior! First step was building a single Perceptron from scratch — the simplest possible neural network, just one neuron with weights. I trained it to learn how to separate points above and below a line, and you can literally watch it learn live: it starts with a random decision line, and one point at a time it adjusts its own weights until the line converges to match the real one. Points get circled green when the perceptron guesses right and purple when it’s wrong, so you can watch it get better in real time.This is step one of a much bigger plan — eventually I want my creatures’ behavior to come from an evolved neural network instead of me hardcoding “flee predator, seek food.” A perceptron obviously can’t do that on its own, but it’s the building block everything else is made of, so I wanted to actually understand it before jumping straight to neuroevolution. Next up is stacking these into a real multi-layer network, and then evolving them instead of training them with math. Thanks for reading, see you next devlog!

What’s up guys! Big update this time…

I finally added predators — they hunt prey and meat, and now have their own mating animation that’s different from prey’s (gliding together with a little weave, nose-to-nose instead of tail-to-tail, then a baby appears). Prey also got real genders now, and mating actually mixes both parents’ DNA (with a chance of mutation) instead of just copying one parent. Prey can flee from predators too.The coolest new thing is “predatorify” — if a prey eats enough meat, it transforms into a predator! Still tuning how easy that should be to trigger.Also added a population graph (rolling + full history) and a click-to-inspect feature so I can click any creature and see its type, lifetime, health, gender, and DNA. Microorganisms are wandering around chasing meat now too.Basically this session was about making all the systems actually talk to each other — hunting, fleeing, mating, dying, and feeding back into the ecosystem. Starting to feel alive! Thanks for reading, see you next devlog!

What’s up guys! It’s me! And I am here to tell you my progress…

I think that this is the most progress I have made yet. I have made a lot of systems, and I am going to run you guys through it. The first system, is the actual environment, and actually made the triangles, but decided that I would make my own design and it is pretty simple. I also made debugging circles that you can turn on and of with right click, and you can add new preys with left click. I have the preys on the environment right now, but I am going to add all sorts of things later! Also, there is mating in the whole environment so the preys don’t get extinct. I am still playing around a bit in the parameters and I am going to add predators, since I added meat into the environment too. I really like this project, and I think I will keep going! Thank you for reading this devlog! (The video is a little taste and the show case of the environment)

I am here with the new information…

I made a new particle system to make a new vehicle that can pursue the mouse, and this will be a great way to start off since we need to teach the vehicle to move and pursue the target. We also need to teach them about avoiding the target. All I did was find a lot of information about that and finished making the particle system. I broke that particle system right now because I want to change that particle system into the vehicle. So I don’t have something to post in my pictures page right now so I just leave the picture of the very first none moving triangle vehicle, just so you can see the very first ever design of it.

What’s up guys, I finally started to start coding and…

Hello guys! I started to work on my code for this project! I decided to start from scratch, and start over! The tutorial wants me to use p5.js, but since I want to learn MORE :) I decided to right all of the code and the classes from the start and that is what made me code for THIS LONG! What I have right now is a circle that can accelerate and have velocity, and all of this is based off a custom class, and it also has custom vector creations! The whole this is really going along really well, and I really like the progress! Also, I can learn math along this journey! I hope you can follow along more in this journey and see you in the next devlog! This is the custom, accelerating, velocity, vector, sphere thing :) :

I am back with a new project! And it is not small…

I decided to start a new project, and it is a rather new type of project that I started to plan on. It is called DYCOSYSTEM. Dycosystem is a harware object either a cube or a sphere and there will be a syringe that can control the whole digital ecosystem. The sphere and the cube will both contain a special ecosystem, that will have digital life, and they will evolve as the time goes on. also, I will add special sounds to the animals to add sound and more diversity in the enviroment. I hope you guys can follow along my journey, and I hope I will finish this project! :) Today, I just went through youtube tutorials about vectors and inheriting and artificial life, so I couldn’t code, but still follow along! (I had nothing to add here so I just dropped a picture of my very simple plan below(IT IS ACTUALLY SO SIMPLE))