Projects, art, creations

Silvestris 🐈🪽

WARNING! VERY early work in progress.
More details are to come.

Silvestris is a computer architecture designed for application virtualisation, but extensible to be able to fill many roles in many environments.

Compared to other options...

• Compared to classic systems programming languages like C or C++, it provides isolation from the host system and abstraction layers for various features, on top of guaranteeing "upper-bound" memory limts and safety.
• Compared to the typical desktop/server virtualised options like the JVM or dotnet, it is significantly more lightweight: 1) permitting its usage in embedded applications or streaming a tiny runtime over the web (still far smaller than many common JS frameworks), and 2) drastically reducing warmup and cooldown times for ad hoc nano-applet execution.
• Compared to common scripting languages like JavaScript or Python, it offers a far higher degree of predictability and performance (unless 1. intensive calculations are performed, and 2. a JIT compiler is used for the scripting language), on top of lower overhead when accessing "systems"-level features like accelerated graphics and massive asynchronous multiprocessing.

More details are to come!

WARNING! VERY early work in progress.

LIGeR is a project that, while it has only recently taken shape, has been gnawing away at the back of my brain for years.

To put it briefly, if you want an interface done natively and lightly, you talk to your compositor directly, and if you want to have something easily cross-platform, you use something like Electron.

But what if you want both?

That's where LIGeR comes in! It's a... widget toolkit? abstraction layer? ...I'll find the right words in time, but it's a thing that allows you to type up a little shorthand and have an interface appear on screen anywhere, anytime.

With SDL3, even with an existing widget toolkit like GTK, Qt, whatever, or even in the text terminal — LIGeR takes the weight off of your shoulders and allows you to use a high level of abstraction in describing your interface. It'll handle the rest.

Everything else

As just a teaser, here are the codenames of all the currently open ideas, whether they be specifications, specific pieces of software or otherwise...

• Silvestris — a virtualisation-oriented architecture and associated file formats.
• Silvestris runtimes:
  • Nebelung — a "batteries-included" desktop/server runtime with JIT capabilities (like the JVM)
  • Munchkin — a hyperlightweight "need-to-link basis" runtime for bundling with Silvestris disks so they can be ran on a Silvestrisless system (like Electron) or for embedded/web applications
  • Ragdoll — a "statically-linked standard library" solution for a fully-natively-compiled Silvestris application (like the Rust standard library or the Go runtime)
• Programming languages:
  • Tabby — a "scripting-style" language with an emphasis on easy learning and easy parsing. The Tabby compiler can also interpret line-by-line, and interface with Nebelung (if present) to JIT the code in parallel.
    • Tabby-Mackerel — the "base dialect" of Tabby. Perfect for simple application programming and scripting.
    • Tabby-Blotch — a Tabby dialect with a greater emphasis on being "shell-like" with POSIX-flavoured syntactic options. Perfect for scripting and interactive use: available as a UNIX shell.
    • Tabby-Spot — a Tabby subset meant to be vaguely comparable to Lua - perfect for embedded usage and micro-applets.
  • Tuxedo — a highly rigorous "C-like" language. Perfect for application programming and as a Silvestris reference point.
  • Calico — a slightly avant-garde language with a powerful standard library and a fresh, human-friendly syntax, with the ability to fully leverage the fault tolerance and massive async capabilities of Silvestris. Perfect for heavyweight application programming.
• Hardware abstraction frameworks:
  • Caracal — a high-compatibility, decent-performance (preference for reliability and compatibility) abstraction for 2D and 3D graphics that runs the appropriate graphics API or a software renderer under the hood to deliver a common interface for displaying "plain" and interactive graphics.
  • Leo — a "flexbox-like" visual space partitioning and content definition system independent of DPI.
  • Tigris — a state-machine-based definition system for traversing logical nodes for presenting or loading various sets and subsets of content.
  • LIGeR (Layered Interface GEneralisation pRotocol) — a complete GUI solution for "any-with-any" programming language / widget toolkit combo, based on Leo and Tigris.
  • Serval — a simple sound output API that combines the functions of a streaming audio player, sound tracker (general-purpose sequencer) and "reactive" (on-click, on-open) chime/signal/bell/"ding" handler.
• EUPHRATES (Extensible Universal PHenotyping for Retraceable Asset Transmission, Encoding & Storage) — a protocol for hashing, signing and validating a "stamp" or "signature" for a piece of content for easy tracking of changes and, given trusted sources, finding original "full-quality" sources of content. Tabby-Nebelung can leverage EUPHRATES to immediately run compiled Tabby programs if they've been compiled before, without recompilation, even if they're ran as scripts, because it can see there had been no changes.
• Eye of Tigris — a software for displaying "rich content" based on Tigris and Caracal that permits for high-efficiency delivery of short-form animated content and animated content with light interactivity on any platform. Using Euphrates signing allows EoT to compress the content and add the appropriate hashes to allow the original to be retraced.
• YapYap — a communication standard that allows for direct messaging, semi-public and public posting, based on Euphrates, LIGeR and Silvestris, permitting fully decentralised and secure transmission of data efficiently.