Pulse 1.5: A Deterministic Runtime You Can Actually Rely On

After a long cycle of refactoring, cleanup, and verification, Pulse 1.5 is finally out. This release focuses on one thing: making the runtime fully deterministic, predictable, and stable for real work. No magic tricks. No vague ideas of “maybe this works.” Everything is now measurable, testable, and reliable.

If you tried Pulse early on, this is the version that fixes the rough edges, standardizes the APIs, and brings the runtime to a place where you can actually build things without guessing how the scheduler will behave.

What Pulse Tries To Solve

JavaScript async is powerful, but it can also be chaotic. Tasks interleave in ways that are hard to reason about, timing bugs appear randomly, and reproducing issues can be painful. Pulse was created to give developers a model where:

• The same input always produces the same execution.
• Concurrency behaves in a predictable way.
• Channels, select, and tasks follow deterministic rules.
• Async code can be tested without racing conditions.

Pulse 1.5 is the first version where all of this is solid.

What Changed in Pulse 1.5

1. A fully deterministic scheduler

The scheduler is no longer a mix of helpers. It is now a proper deterministic engine:

• Logical time is advanced tick by tick.
• Tasks are executed in a stable order.
• Sleep operations follow predictable wake times.
• Channel operations follow strict FIFO rules.
• Select always resolves using well defined priority rules.

There are zero hidden timers or tricks. Everything is explicit.

1. A complete internal cleanup of concurrency primitives

Channels, select, spawn, sleep, and task lifecycles were rewritten so they behave exactly as documented. No shortcuts. No undefined behaviors. All operations now return consistent data structures and error shapes.

1. Stable and copy paste friendly documentation

All documentation examples were updated to sync with the actual runtime:

• All examples now use the real version of select.
• No more old syntax from early experiments.
• No more DeterministicScheduler references.
• All examples compile and run exactly as written.

In short, if you copy it, it works.

1. A complete refactor of the scheduler internals

The runtime now has:

• A SchedulerCore base class.
• A GlobalScheduler for CLI tools.
• A unified task model.
• A predictable microtask flush mechanism.
• Task completion promises.
• Task trees for parent and child relationships.
• Automatic cancellation and cleanup.

This gives us a strong foundation to build the next major feature: server-side scheduling.

1. Fixes across the entire codebase

We removed every broken, outdated, or inconsistent piece of the concurrency API. Select now returns the correct values everywhere. Channels clean themselves up when closed. Error handling is consistent.

1. All tests pass with zero tolerance for failure

• All deterministic scheduler tests pass.
• All channel tests pass.
• All select tests pass.
• New tests were added for determinism, task ordering, and edge cases.
• All examples were rebuilt and verified.

Pulse 1.5 is now stable enough to build real tools and CLI applications without surprises.

What Pulse 1.5 Cannot Do Yet

I have to be clear. HTTP handlers still cannot use Pulse primitives like spawn, channels, or select. HTTP still runs on the Node event loop and is not yet integrated with the deterministic scheduler.

The next version will solve that.

What Comes Next: Runtime 2.0

The next step is a full rewrite of how Pulse interacts with Node. This is a large project and will take time, because it requires:

• A cooperative scheduler that yields to Node.
• A request scoped scheduler for HTTP.
• Safe and predictable task cancellation.
• Pools of schedulers for high concurrency.
• Deterministic execution inside each request.

This is a major change, and it is happening now.

If you want to help

If you tried Pulse before, I would really appreciate it if you could try version 1.5. I spent a lot of time fixing everything that felt unstable or unclear. This release is much stronger, and your feedback is very helpful for shaping Runtime 2.0.

You can check the docs here:
https://osvfelices.github.io/pulse/

How to try it out

npx create-pulselang-app my-app  
cd my-app  
node bin/pulse run server/main.pulse 

If you find something broken, unclear, or surprising, please open an issue or share it with me. Everything helps.

Final thoughts

Pulse 1.5 is not the final vision of the language. It is the version where everything becomes solid and predictable. Before adding new features or making HTTP a first class part of the runtime, we needed a foundation that we can trust. This version finally delivers that.

If you try it, thank you. Improvements only happen with real usage and honest feedback.