Project Verona: Fearless Concurrency for Python

Project status & Microsoft context

• Discussion opens by asking what Verona/Pyrona’s future is after Microsoft laid off the Faster CPython team.
• Some note Verona sits under Microsoft Research rather than product orgs, which may give different (but not guaranteed) protection.
• Others argue that given broad layoffs and Python specialists being cut, developers should be cautious about relying on Microsoft-backed Python tooling.

Python performance, GIL, and concurrency pain

• Several comments describe painful experiences scaling Python web backends: GIL, slow single-thread performance, need for many processes, async complexity, and explosion of DB/API connections.
• Others counter that Python is “fast enough” for many workloads, with Cython/Rust for hotspots, and that Python’s real advantage is rapid prototyping, iteration, and friendliness to non-programmers.
• There’s agreement that Python’s dynamism makes JITing and parallelism harder than in some older dynamic systems (Smalltalk, Lisp, Self).

Language evolution, typing, and “Python 4”

• One line of discussion suggests a future “Python 4”: fully typed, Rust-like ownership, less concerned with backward compatibility, especially if LLMs make large-scale rewrites cheap.
• Pushback: at that point it’s essentially a new language; Rust/OCaml/Go/D already exist for that niche.
• Others emphasize that code is largely a liability, not an asset; breaking compatibility discards a huge base of battle-tested code and LLM training data.

LLMs, higher-level abstractions, and determinism

• Some see 3GLs fading in an “AI-dominated” future, with systems going straight from natural-language-like specs to executables, akin to long-promised 4GL/CASE tools.
• Others argue strongly that prompts are a terrible “programming language”; formal languages will still be needed for precision, debuggability, and safety-critical domains.
• Debate centers on determinism vs predictability: compilers have clear semantics and correctness notions, whereas LLMs are inherently harder to reason about and control.

Alternative runtimes and implementations

• Several wish Python had moved to BEAM or at least embraced JITed implementations like PyPy; instead CPython dominates and alternative JITs are seen as second-class.
• Cinder (Instagram’s fork) is mentioned as an actively developed JIT that should remain compatible with free-threaded/nogil Python.

Pyrona’s ownership model

• One commenter notes Pyrona’s “fearless concurrency” is enforced at runtime, not compile time.
• This likely won’t prevent shipping bugs, but may make concurrency errors more reproducible, detectable in CI, and easier to diagnose—still weaker guarantees than Rust-like static analysis.