NewLib Is Public: A Larger Part of NewAge Comes Into View

NewLib is now public.

That is a simple sentence, but it carries a great deal of history for me.

NewLib has existed in one form or another through years of development. It contains mathematical types, image structures, execution tools, graphics support, signal-processing utilities, and many of the smaller foundations that accumulated while I was building larger systems.

Some parts began as answers to immediate problems. A linked list needed a cursor that could survive mutation. An execution system needed to insert, remove, and replace work while it was running. Image data needed to move safely between managed arrays, native code, Skia, and OpenGL. Mathematical types needed to serve both ordinary calculations and graphics transformations without losing the distinction between a point and a homogeneous vector.

Over time, those answers stopped being isolated solutions. They became a library family.

More Than Opening a Repository

Making a repository public is not the same thing as merely changing its visibility.

Private code can rely on the memory of the person who wrote it. It can assume the surrounding workspace exists. It can carry old experiments, unexplained build conventions, and relationships that make sense only because they have been lived with for years.

Public code has to begin speaking for itself.

That meant looking carefully at NewLib as another developer might encounter it. What are the real assemblies? Which dependencies are required? What builds first? Which parts are mature? Which parts are still evolving? Where are source files generated? Which old paths have been superseded? What is the intended relationship between the mathematical layer, the image layer, CrystalCatalyst, Skia, and OpenGL?

The process was larger than cleaning a repository. It was an act of clarification.

NewLib now presents itself as four related assemblies:

Lightning.V1
     |
   NewLib
     |
NewLib_Crystal
     |
  GLInterop

Each layer adds a different capability without forcing every consumer to accept the dependencies of the layers above it.

Lightning.V1 provides low-level collections, cursor-driven structures, threading and batching tools, signal processing, streams, dynamic dispatch, and the Tape execution system.

The central NewLib assembly provides mathematics, geometry, color and pixel structures, Eisel image buffers, interpolation, paths, cameras, frustums, data utilities, and other reusable foundations.

NewLib_Crystal forms a narrow bridge between Eisel, CrystalCatalyst PixData, and SkiaSharp.

GLInterop adds the OpenGL layer: textures, shaders, buffers, vertex arrays, models, samplers, render targets, and screen-space drawing.

Seeing that structure clearly expressed was one of the most satisfying parts of the release.

A Library Shaped by Real Work

NewLib was not designed all at once from a blank page.

It grew from actual projects.

Tape emerged from the need for execution that could remain open to change. Its steps can advance, hold their position, insert new work, remove themselves, or expand into a new sequence. Enumerator-backed steps can preserve local state and yield across repeated executions.

Eisel emerged from the need for image memory that remained useful in managed code while also being available to native and graphics systems. Its lease model temporarily pins the underlying array, giving Skia, CrystalCatalyst, or OpenGL a valid pointer without surrendering ownership of the buffer.

The vector and matrix systems grew alongside rendering work. Pixel types grew into generated families because channel order and numeric precision matter. GLInterop evolved from direct native stubs toward Silk.NET, allowing the managed layer to remain close to OpenGL while removing an unnecessary layer of hand-maintained native forwarding.

These pieces carry the record of problems that were actually encountered.

That does not mean every area is finished. NewLib includes stable foundations, active development, and a few early-stage utilities. Publishing it does not require pretending otherwise. It means the project has reached a point where its current shape, its history, and its future direction can be shared honestly.

The Public NewAge Foundation

NewLib is also significant because it completes a larger public picture.

JWCEssentials, JWCCommandSpawn, CrystalCatalystLibrary, and NewLib are now all publicly available.

Each repository has a distinct responsibility:

JWCEssentials
    Foundational native utilities
    Workspace conventions and staging
             |
    +--------+-----------------+
    |                          |
    v                          v
CrystalCatalystLibrary    JWCCommandSpawn
Windows and graphics      Processes and shells
Pixels and input          Pipes and external tools
    |                          |
    +------------+-------------+
                 |
                 v
               NewLib
    Collections and execution
    Mathematics and geometry
    Images, Skia, and OpenGL

JWCEssentials establishes the shared ground. It provides foundational native structures, utility code, build conventions, workspace configuration, and predictable artifact staging.

CrystalCatalystLibrary gives applications a native surface: windows, events, pixel presentation, OpenGL contexts, cursors, icons, clipboard operations, drag-and-drop, and managed access to those capabilities.

JWCCommandSpawn gives applications a controlled connection to the surrounding tool environment through subprocesses, shells, standard streams, command escapement, and persistent command sessions.

NewLib builds above those foundations with the managed structures from which larger applications and experiments can grow.

For a long time, I understood these relationships mainly from inside the work. I knew why one project depended on another because I had followed the path by which the dependency came into existence.

Now that architecture can be seen from the outside.

Giving the Projects Their Own Pages

As part of this milestone, I have also published a new overview of the public NewAge software projects:

Public Software Projects: The NewAge Ecosystem

The overview began as an attempt to describe all four repositories on one page. That quickly became too large. Each project had enough architecture, history, and practical capability to deserve a page of its own.

That realization was encouraging.

These are no longer just repository links accompanied by a sentence or two. They form a body of public work with enough substance to be explained in depth.

The new overview page serves as the entry point. It describes how the repositories fit together, the principles they share, and the boundary each one owns. From there, readers can move into the individual project pages for a deeper look.

Cross-Platform Without Pretending Platforms Are Identical

One principle runs through all four repositories.

Portability does not mean erasing the differences between Linux and Windows.

Paths differ. Process creation differs. Shells differ. Window systems differ. Native graphics initialization differs. Clipboard and drag-and-drop protocols differ. Even command-line quoting depends on which program will interpret the text.

The goal is not to hide those facts until they become surprising failures. The goal is to give them an intentional place.

Portability does not require erasing platform differences. It requires giving those differences an intentional place.

That philosophy has shaped the platform directories, exported native APIs, managed wrappers, workspace lanes, shell escapement modes, pixel formats, and memory-ownership contracts throughout the ecosystem.

The shared surface should be simple, but it should not become unaware of the systems beneath it.

An Infrastructure Milestone

There are more visible kinds of software milestones.

A new application can be opened. A visual effect can be demonstrated. A benchmark can be measured. A user can immediately see the result.

Infrastructure milestones are quieter.

They happen when a build becomes repeatable, when a dependency becomes explicit, when a native boundary becomes stable, when memory ownership becomes safe, when several projects stop carrying separate versions of the same idea, or when a private body of work becomes understandable enough to share.

NewLib becoming public is that kind of milestone for me.

It does not mark the end of NewLib’s development. In some ways, it marks a new beginning. Public visibility creates a clearer standard. Documentation matters more. Build assumptions must remain visible. Experimental areas need to identify themselves honestly. The relationship between components must continue to become easier to understand.

But the threshold has been crossed.

A substantial part of the software foundation behind NewAge is no longer hidden behind private boundaries.

Looking Forward

There is still much more in NewAge than these four repositories.

Sigmas, symbolic processing, application systems, rendering experiments, and other layers continue beyond the current public boundary. Some of them depend upon the foundations that have now been released. Others will need further preparation before they can follow.

I do not want to rush that process.

The value of this milestone is not that everything has suddenly become public. It is that the public foundation is now real, coherent, buildable, and substantial enough to support what may come next.

JWCEssentials, JWCCommandSpawn, CrystalCatalystLibrary, and NewLib are individual projects, but they also tell one continuing story:

Recurring problem
    -> reusable solution
    -> shared infrastructure
    -> explicit boundary
    -> public foundation

That is how much of NewAge has grown.

Today, NewLib joins that public foundation.

I am proud to finally share it.