Uploaded June 2026 | Updated September 2026, 2 hours ago
Living text for your lore and worlds.
dscript.org/dscriptor
Free Live Web APP ,or, Download Standalone EXE
Make your in-game script actually feel alive.
Stop using repetitive fonts that instantly break immersion.
Design one alphabet and generate an infinite family of styles.
Add natural handwriting chaos with custom Scribe personalities.
Take those glyphs and instantly carve them into 3D assets.
So here is a breakdown of the software I am messing around with in the video. Standard fonts usually look way too sterile and machine-like when you are trying to build lore for games or media, so I built this system to create custom scripts that actually feel grounded in reality.
It all starts in the editor canvas. There is a built-in muse system to bootstrap your creativity so you can rapidly crank out a ton of glyphs without sitting there staring at a blank screen. The big difference here is that you are working in an environment where everything is separated into individual strokes instead of just flat static pixels.
Because all of this is stored as stroke data inside my custom rendering engines, a single set of characters goes a really long way. You just build one base character bank and you can instantly generate a whole family of fonts. You can spin up a strict rigid version for a formal document, a weathered and worn down version for ancient ruins, or something totally blobby and poorly drawn.
But the real meat of the tool is the Scribe system. This is basically a custom drawing and text program that takes those stroke-based glyphs and actually writes them out. Since it understands the individual strokes, you can design specific personalities for your scribes. You give the system an initial style and then let it add natural variations. It shifts the position, tweaks the rotation, alters the thickness and curvature, etc.. . of the individual strokes making up the letters.
This is where the living text stuff really shines. If you type the exact same character over and over again in a sentence, every single instance will look completely unique. You can crank the random variations way up so the handwriting is an absolute chaotic mess, or you can dial it back so there is just enough subtle randomness to look like an authentic human actually wrote it. It completely kills that repetitive tiled look that ruins immersion, but you can still just use them as a completely standard original font if you want.
Finally, since your lore usually needs to exist on objects in a physical space, there is a whole 3D asset side to this. You can take the script you just generated and use it to directly stamp, carve, or extrude assets right inside the system. It makes it super easy to bridge the gap between designing a written language and physically carving it into your world.
#gamedesign #3dassets #worldbuilding #gamedev #unrealengine5 #unity3d #conlang #conscript #scripts #glyphs #symbols #lore
Living text for your lore and worlds.
dscript.org/dscriptor
Free Live Web APP ,or, Download Standalone EXE
Make your in-game script actually feel alive.
Stop using repetitive fonts that instantly break immersion.
Design one alphabet and generate an infinite family of styles.
Add natural handwriting chaos with custom Scribe personalities.
Take those glyphs and instantly carve them into 3D assets.
So here is a breakdown of the software I am messing around with in the video. Standard fonts usually look way too sterile and machine-like when you are trying to build lore for games or media, so I built this system to create custom scripts that actually feel grounded in reality.
It all starts in the editor canvas. There is a built-in muse system to bootstrap your creativity so you can rapidly crank out a ton of glyphs without sitting there staring at a blank screen. The big difference here is that you are working in an environment where everything is separated into individual strokes instead of just flat static pixels.
Because all of this is stored as stroke data inside my custom rendering engines, a single set of characters goes a really long way. You just build one base character bank and you can instantly generate a whole family of fonts. You can spin up a strict rigid version for a formal document, a weathered and worn down version for ancient ruins, or something totally blobby and poorly drawn.
But the real meat of the tool is the Scribe system. This is basically a custom drawing and text program that takes those stroke-based glyphs and actually writes them out. Since it understands the individual strokes, you can design specific personalities for your scribes. You give the system an initial style and then let it add natural variations. It shifts the position, tweaks the rotation, alters the thickness and curvature, etc.. . of the individual strokes making up the letters.
This is where the living text stuff really shines. If you type the exact same character over and over again in a sentence, every single instance will look completely unique. You can crank the random variations way up so the handwriting is an absolute chaotic mess, or you can dial it back so there is just enough subtle randomness to look like an authentic human actually wrote it. It completely kills that repetitive tiled look that ruins immersion, but you can still just use them as a completely standard original font if you want.
Finally, since your lore usually needs to exist on objects in a physical space, there is a whole 3D asset side to this. You can take the script you just generated and use it to directly stamp, carve, or extrude assets right inside the system. It makes it super easy to bridge the gap between designing a written language and physically carving it into your world.
#gamedesign #3dassets #worldbuilding #gamedev #unrealengine5 #unity3d #conlang #conscript #scripts #glyphs #symbols #lore








![Server Injection and Multi threading core - Toobit 0.12/0.13 opensource cellular automation
SOURCE CODE and more info
http://github.com/vastencn/toobit
Primary goals so far are
Target : Small cheap ARM systems
Code : Semi-Optimized C Prototype
Application : Server based cellular automation platform
Toobit is a Project with documented development.
Video documentation is regularity done and frequent version backups are made as well.
This way the project is either useful as a framework and as a reference for the design of such a platform from scratch.
Features to date:
-function pointer based automation
(just design the physics as a function and pass that function into the core)
-Safe pointer based pre-processing
(faster access to neighborhood and no need to worry about boundaries)
-Server (Can handle HTTP request)
-Thin Terminal Client (Can deliver and then service a HTML5/Javascript/etc.. client)
-server raw output dump and client injection
-Threading core(lock stepped core of 3 threads to help max out cpu usage..[adjustable thread count coming..])
-Some basics like screen print, speed test, init functions etc..
Future plan.. too many to count but some are
-Mesh networking to allow them to join and sync into larger universes.
-serial node based processing (out from 1 is input into 2.... output 2 into input 3 etc..)
-Visual effects, music viz
-Unreal, Unity, Blender, etc.. pluigin to stream the output into the 3d world as textures, maps, particles, etc..
-so much more.. with little arm systems you could build complex networks of these and do all kinds of i/o :)
Youtube Playlist of Toobit Video Documentation
https://www.youtube.com/playlist?list=PLmSUTHzWYMaNGqxUQunqIu3TbsDL2QnI-
//
// TOOBIT v0.5
// 2d bit space simulation system
//
// Toobit is part software project, part experiment, part educational material
// Goals
// -Framework : develop an optimed platform for complex digital virtual physics systems
// -Study : experiment with said systems and seek shiny stuff
// -Educational Media : document the development on youtube with explaination
//
// Complex digital virtual physics systems means systems that have common rules applied
// constantly each frame of time to every point of space. Conways Game of Life is a
// well known example. Many much more complex systems have been devised and documented.
// The goal here is not to design one, but explore the developement of an optimized
// virtual physics design framework.
//
// I play with alot of embeded ARM systems these days, so I want fast, small and tight
// you have a dirty mind
//
// Just simple C, its what I am best at and what seems to be more rare the days.
//
// A major focus here is optimization. This game is all about how big you can make space,
// how complex the rules can be, and how fast you can run time.
//
// This will manifest itself in several visible ways
// -pointers pointers pointers!
// -Avoidance of restrictive elements
// -Heavy use of preprocessor
// -Recompile required for many config changes
//
// *note* threading is planned, but there is much else that must be designed first
//
// Youtube Playlist of Toobit Video Documentation
// https://www.youtube.com/playlist?list=PLmSUTHzWYMaNGqxUQunqIu3TbsDL2QnI- Server Injection and Multi threading core - Toobit 0.12/0.13 opensource cellular automation](https://i.ytimg.com/vi/jYLREQd2Hlc/mqdefault.jpg)

