Ductus

Study

My handwriting sucks. VHS kinda tries to fix this with hardware support.

But of course automating it did not make my own handwriting better. It mostly madbit …faster.

I would like my handwriting to become more readable, more consistent, and more beautiful. Not only everyday handwriting. Also calligraphy, lettering, fountain-pen writing, and maybe better source glyphs for VHS. It also sits next to Writing by Hand, because this is the same old question with software wrapped around it: what does the hand learn when writing slows down?

I also have a small pile of pen-enabled devices. Windows laptops with pen interfaces. Android and iPad tablets. My phone. Two e-book readers with pen support. They should probably do something useful at some point.

During VHS I learned that pen strokes can be recorded directly in HTML and JavaScript. Coordinates, timing, sometimes pressure. No native app needed. That made Ductus tempting in a very practical way: I want to improve my handwriting, it seems easy enough to write a small app for that, and the pen devices are already here.

Of course that is the trap. Recording strokes is easy. Making the feedback useful is the hard part.

Ductus is not proof that my handwriting improved. Not yet. I am still building and testing the app. The current study is more basic: can I make a practice loop that tells me something useful about how I move the pen?

What it is

Ductus is a small browser app for practising ductus: the movement behind a written form. It belongs to the same gesture corner as VHS and Tracer: three small tools that care less about polished shapes and more about how a line was made.

It compares how a stroke was made. Order. Direction. Path. Pressure. Rhythm. A final letter can look close while the movement is wrong. A stroke can start in the wrong place, run backwards, carry too much pressure, or arrive at the right shape by stopping and rebuilding itself in pieces.

That is the bit I want to catch.

The app currently has a practice mode, an author mode, a small Kurrent Basic hand, and five score bars. It runs in the browser, works offline after loading, and has no backend, account, or analytics. That makes it a small browser thing like Tracer, not a big learning platform.

Current state

The repo is ahead of the public idea and behind the actual ambition. Normal.

Ductus can already capture stylus and mouse strokes. It records pressure when the device and browser expose it, the same awkward browser input problem that also matters for Tracer. It has warm-ups for hairline, downstroke, and compound curve. It also has a first lowercase stem sequence for Kurrent Basic: i, u, n, and m. Attempts can be scored, exported as .txt, and used as reference material in author mode.

The scoring is split into five parts:

• form
• order
• direction
• pressure
• rhythm

One total score would hide too much. A stroke can have the right shape and the wrong direction. Pressure can look plausible while the path wanders away. Order can fail because I made one stroke where the reference expected two.

The useful work right now is testing, not claiming success. Android Chrome with a stylus already gives real pressure values. That is good. It also means the app has to admit when another device gives flat or missing pressure, noisy timing, or only partial data. PPCT does the same kind of unromantic work for pens and paper: test the setup before trusting the result.

The stem references are starters, not a master hand. I put them in so the app can finally support a short practice run instead of one lonely n. That is better, but it also makes the next failure easier to see.

So no, Ductus is not my handwriting teacher yet.

It is the thing I need before I can find out whether a browser can become one.

Next

The next useful work is boring in the correct way: use the thing.

I need a real ten-minute stem session on a tablet: warm-ups first, then i → u → n → m. Save the attempts. One decent try and one ugly try for each glyph would already tell me more than another hour of tuning from imagination.

If the starter references are wrong, good. Then they get replaced with reviewed stylus exports. If the scoring is wrong, also good. Then the exports become fixtures. The point is to stop guessing where the hand is bad and where the software is bad.

After that, Ductus needs better feedback. A low bar is not enough. A mark on the stroke. This part was too heavy. This part reversed. This pause made the rhythm weird. Something I can practise from.

If pressure starts to matter physically, the path probably leaves Ductus and goes through VHS, Tracer, and then Gantry. Ductus can teach the hand. The other tools can ask whether some of that movement survives when the plotter draws.

Then, maybe, I can use it for ten minutes and see whether my hand learns anything.

Launch: simiono.com/ductus · Mirror: utrost.github.io/ductus · Source: github.com/utrost/ductus · Roadmap: docs/roadmap.md

See also: VHS, Tracer, Writing by Hand, ClefHanger, From Pixel to Pen, Gantry, PPCT, Workbench, Studies