3D-Printed Clock Movement
A working clock movement printed on a 3D printer — escape wheel and anchor included.
Shawn Chang
Taichung First Senior High School · Math and Science Gifted Class
—
Tap any tile to jump to it
Spaced repetition for high-schoolers cramming for Taiwan’s GSAT.
Not another generic vocab app — it does this one thing.
Generic vocabulary apps teach words in whatever order a publisher chose. A GSAT student needs one specific word list by one specific deadline — and forgets most of it within days unless each word comes back at the right time. I needed that myself, so I built it.
A spaced-repetition scheduler built around the exam word list: every word returns shortly before you’d forget it, and nothing outside the GSAT scope gets in the way. Serving one audience meant skipping the decks and settings a general app has to carry.
Keeping every card’s review state correct across sessions and offline, while thousands of cards stay instant to schedule and scroll.
1,000+ users and a #5 ranking in Education on the App Store, with zero ad spend — all of it from a single post on my school’s forum.
The high-level policy sees the tower but not the contact.
How much does it help to let it read what the low-level controller knows?
Whether a block is loose or tight can only be learned by touching it — no still image of the tower shows it. The high-level policy only gets a snapshot of block poses, so it cannot see what is happening at the point of contact.
A hierarchical split: the high level chooses which block and when to give up; the low level controls the arm to push the rod. The low level is trained purely for control and is blind to the global picture.
Proving any gain comes from reading, not retraining. The high level queries the low level’s hidden states through cross-attention, while the low level stays frozen and receives no gradients — so an improvement has to come from what is read, not from the low level reshaping itself to help.
So far, the task itself is validated: friction is bimodal (some blocks loose, some tight), and diagnostics confirm outcomes depend on it and nothing leaks through the static view. I’ve also measured the most the contact-force channel can tell a policy, which sets the baseline’s ceiling. The main experiments are next.
Four legs, two boards I drew myself.
A desk built end to end, from mechanism to firmware.
Store-bought standing desks are black boxes: you can’t see how they stay level or what happens when a motor stalls. I wanted one I understood completely — and could change.
Four driven legs coordinated by a controller board, with the user panel on a second board so each can be revised without redoing the other.
Keeping four legs in step: detecting lost steps, enforcing travel limits, and remembering height across a power loss.
Mechanism, two PCBs and firmware, working together — and in daily use.
Notes that grow like a tree.
Every thought branches from the one before it, so you see how ideas connect — not just that you wrote them.
Linear notes flatten thinking. An idea rarely arrives alone — it comes out of another one — and a flat list throws that relationship away.
Every idea is a rounded node. New thoughts attach as children and the whole thing grows into a network you move around in, instead of a page you scroll.
Context management: every branch has to carry the right context from the nodes above it — enough to make sense on its own, without dragging in the whole tree.
170+ users signed up, and nobody came back. The lesson was blunt: build things I actually use myself. That’s why Snowball Vocab started from my own need.
Hierarchical path planning plus stochastic simulation.
With fire spreading and routes closing, the question isn’t “how long” but “what does the distribution look like.”
Evacuation isn’t a one-shot static shortest-path problem. Fire spreads, routes get cut, and people have limited sight and are afraid. The environment keeps changing, so paths must keep being recomputed.
The floor is abstracted into a graph of doors and exits: the upper layer plans routes between doors with Dijkstra, the lower layer handles real-time movement inside rooms with D* Lite. With two layers, a change only triggers a replan in the layer that needs it.
Incremental replanning with D* Lite, knowledge sharing between agents under partial observability, and the fire model itself — temperature, oxygen, smoke and fuel fields running together.
Parallelized Monte Carlo: every run randomizes the fire origin and starting positions, producing a statistical distribution of evacuation times rather than a single number.
Does reward design actually matter? A controlled study on Basket Random, a one-key game.
Here, barely — and that turned out to be the finding.
I wanted an agent that could beat my classmates at Basket Random — one key, ragdoll physics, body parameters re-randomized every round. Early agents seemed to stall by hogging the ball, so the real question became: did my reward design cause that, and does shaping the reward help at all?
Instead of reading the screen, I inject the game state straight into the agent as a 66-dimensional vector, then run three reward designs head to head, plus variants with and without a possession reward.
Training speed. Screenshots through a CNN were too slow to run real experiments; state injection trains 23.1× faster, and batched IPC with fast resets adds another 3.42× throughput.
About 70% win rate against the built-in AI — and all three reward designs landed within 1.5 points of each other. Goals come every ~280 steps, so the reward was never sparse. Start with the simplest reward; add shaping only when learning stalls.
A working clock movement printed on a 3D printer — escape wheel and anchor included.
A floating window that transcribes and translates speech live, so I can follow K-pop livestreams without leaving the video.
Students enter their scores and past ranks; before the official ranking is out, it estimates where this exam will put you.