Welcome to LingFrame V0.3.0.

This release is not about adding another batch of isolated features. It is about converging governance capabilities that were previously scattered across multiple invocation paths into a reusable, explainable, evolvable runtime kernel.

The core theme of 0.3.0 can be summarized in four words:

• Unify: unify the governance execution spine
• Converge: converge runtime state ownership
• Reuse: reuse the same kernel across Web, Bean, and Dashboard paths
• Stabilize: bring unload, cleanup, and leak diagnostics into long-running runtime responsibilities

Key Highlights

1. The unified governance pipeline is now formally in place

InvocationPipelineEngine and FilterRegistry now form the formal governance execution spine of LingFrame. Calls pass through fixed phases in order:

• TrafficMetricsFilter
• MacroStateGuardFilter
• CanaryRoutingFilter
• ResilienceGovernanceFilter
• ContextIsolationFilter
• GovernanceDecisionFilter
• PermissionGovernanceFilter
• ThreadIsolationGovernanceFilter
• TerminalInvokerFilter

This means routing, resilience governance, context isolation, permission decisions, thread isolation, and terminal invocation are no longer scattered across multiple logic paths. They are now organized into a formal chain with validated order, explainable behavior, and reuse across multiple entry points.

2. The dual-state runtime model is now a formal structure

0.3.0 formally converges runtime state into two layers:

• Instance layer: InstanceStatus describes the lifecycle of a single LingInstance from CREATED to DEAD, written exclusively by InstanceCoordinator
• Runtime layer: RuntimeStatus describes the macro availability of one ling from the LingCore perspective, aggregated by RuntimeCoordinator after subscribing to instance facts

This change makes it much clearer who may write state, how state changes are linked, and when macro runtime conclusions are produced.

3. Lifecycle orchestration has become an explicit capability

DefaultLingLifecycleEngine is no longer just a helper around “hot swap.” It is now the real top-level lifecycle orchestrator:

• runtime registration happens before the first instance facts appear
• deploy drives an instance through LOADING -> STARTING -> READY
• reload uses a side-by-side replacement path: deploy the new instance, cut over traffic, then unload the old one
• unload first marks the instance as STOPPING, waits for in-flight requests to drain, and only then proceeds with cleanup

This gives 0.3.0 a much clearer operational boundary for long-running systems than earlier “hot swap exists” messaging.

4. The same kernel now serves more governance entry points

The governance kernel is no longer limited to standard ling-to-ling invocation:

• Spring Boot 2 / 3 LingWebGovernanceFilter borrows the same pipeline through GOVERN_ONLY
• LingCoreBeanGovernanceInterceptor lets LingCore bean invocation reuse the same governance capabilities
• Dashboard SimulateService runs the real governance chain through SIMULATION instead of maintaining a shadow ruleset

This means the explanations seen by the control surface remain aligned with real runtime governance results.

5. The dashboard is now built on real runtime facts

The governance control surface in 0.3.0 is now increasingly built on real kernel events:

• simulated calls retain EngineTrace
• the event bus publishes trace, audit, circuit-breaker, lifecycle, and leak-detection events
• LogStreamService continuously pushes these events to the control surface through SSE

Canary routing, simulation, lifecycle visibility, and event streaming are now increasingly built around the same runtime facts.

6. Long-running stability is now formally part of runtime responsibility

LingFrame now treats unload and cleanup as part of the runtime contract itself:

• governance resources and method caches held by the pipeline can be evicted during unload
• DefaultLeakDetector emits diagnostics through different strategies in dev mode and prod mode
• leak-detection results also enter the monitoring event stream

7. The Shared API bootstrap boundary is now written into the architecture

SharedApiManager makes startup order itself part of the architectural boundary:

• preload Shared API JARs or classes directories
• register shared package prefixes
• freeze the Shared API boundary
• only then load lings against that frozen contract view

This means a brand-new shared contract may still be introduced before freeze, but an already loaded shared contract still cannot be hot-updated or hot-unloaded in the same process; contract changes require a process restart.

Scope Delivered In 0.3.0

The current public delivery scope includes:

• unified governance pipeline
• dual-state runtime model
• explicit lifecycle orchestration
• dashboard simulation and event streaming
• web / bean governance entry points
• Shared API boundary freezing
• unload cleanup and leak diagnostics

Welcome to LingFrame V0.2.0! This major update signifies the project's pivotal evolution from "fundamental runtime isolation" toward full-spectrum Runtime Resilience Governance (Phase 3). Additionally, we've executed a massive terminology refactoring, rigorously addressed classloader memory leak scenarios, and dramatically expanded ecosystem compatibility to legacy environments.

🎉 Key Highlights

1. 🛡️ Resilience Governance Engine Unleashed

LingFrame now features robust, unit-level micro-governance capabilities native to the JVM:

• Circuit Breaking: Employs a SlidingWindowCircuitBreaker to proactively trip the circuit when an individual unit exhibits a high failure rate, thwarting cascading system outages.
• Rate Limiting: Utilizes a TokenBucketRateLimiter to throttle massive traffic spikes aimed at specific hot-swappable units.
• Retry: Provides a zero-invasive, kernel-level retry mechanism for handling transient failures.
• Fallback: Works in tandem with the SmartServiceProxy to execute graceful degradation routines whenever a unit times out or gets short-circuited.
  All resilience parameters can be dynamically provisioned and updated via the GovernanceManager on the fly.

2. 🔄 Paradigm Shift in Terminology

To irrevocably resolve the conceptual ambiguities surrounding the historically overused term "Plugin", an exhaustive architectural refactoring was executed:

• The concept of Plugin has been officially codified as Ling (Unit).
• The concept of Host has been renamed to LingCore.
• The core descriptor specification mandates the use of ling.yml, discarding the legacy plugin.yml.
• Substantial monolithic renaming of core classes (e.g., PluginManager -> LingManager, PluginRuntime -> LingRuntime).

3. 🐛 Deep Mitigation of ClassLoader Memory Leaks

Hot-swapping logic inside the JVM inherently risks memory leaks arising from retained Classloaders. V0.2.0 addresses this extensively by:

• Aggressively evacuating dormant Singleton and Interceptor caches nested deeply within the Spring Sub-ApplicationContext upon unit teardown.
• Systematically severing static reference chains spanning ubiquitous libraries like Jakarta EL, Objenesis (used for CGLIB caching), and native logging frameworks.
• While JVM mechanics dictate cautious assertions, memory retention has been astronomically reduced across aggressive unit reload cycles—propelling LingFrame toward true industrial-grade stability.

4. 🔌 Expansive Ecosystem Backward Compatibility

Modern dynamic runtime manipulation is no longer restricted to the bleeding edge. LingFrame V0.2.0 extends robust support to legacy enterprise applications:

• Universally validated against JDK 8.
• Introduced the bespoke lingframe-spring-boot2-starter, assuring frictionless assimilation into legacy Spring Boot 2.7.x environments bridging javax.* boundaries.
• (Uncompromised support for Spring Boot 3.x is naturally preserved under lingframe-spring-boot3-starter).

5. 🛠 Developer Experience (DX) Enhancements

• DevMode: Instantiated the lingframe.dev-mode.enabled directive. In DevMode, units are auto-activated immediately post-installation, and extraneous authorization safeguards are relaxed—rendering local testing pipelines phenomenally smooth.
• SpringDoc API Clustering: The Swagger integration has been overhauled to intelligently cluster, segment, and label APIs unequivocally, distinguishing between underlying Host endpoints, Core APIs, and distinct dynamically inserted Ling endpoints.

v0.1.0-preview – Initial Runtime Governance Release
January 30, 2026

LingFrame utters its first sound.
Fragile, yet real.
Direction frozen. Boundaries taking shape.
This is not a finished tool — it is a proof of concept:
Runtime governance within a single process — does it hold?

Project Positioning

LingFrame is a JVM runtime governance framework designed for long-running systems.
It keeps mature monolithic applications stable, controllable, and evolvable — without rewriting the system or forcing microservices splits.

Many systems aren’t poorly designed —
they’ve simply lived too long and been changed too hastily.

Core Capabilities (Validated So Far)

• Plugin isolation with zero-trust calls (Core as the sole arbiter)
• Fine-grained permission control (Annotation + Inference sources)
• Full call-chain auditing and real-time tracing logs (SSE-powered)
• Multi-version coexistence (stable + canary)
• Basic canary traffic shading (proportion-based + weighted routing)
• Optional reference Dashboard (real-time plugin status, canary progress, audit logs, IPC control)
• API documentation integration (SpringDoc + Knife4j support)
• Dashboard multi-language foundation (English/Chinese switching)

Current Stage

v0.1.x · Maiden Phase (Preview)

• No pursuit of feature completeness
• No backward compatibility guarantees
• Single focus: Validate runtime governance viability in a single process
  This is a phase of refusing to please everyone and starting to make deliberate choices.

Technical Boundaries (Overview)

• JVM: JDK 21 / JDK 8 (parallel support; JDK 8 compatibility planned)
• Spring Boot: 3.x / 2.x (compatible)
• Single-process architecture
• Clear distinction: Interface stability ≠ Implementation stability
• Does not hide complexity — only refuses to dump it all on the user at once

Recent Key Changes (Highlights Since Project Start)

• Implemented multi-version coexistence and weighted canary routing
• Added multi-language support and UI localization to Dashboard
• Integrated SpringDoc / Knife4j for improved API documentation
• Optimized plugin management, governance logic, permission strategies, and unit tests
• Switched logging language to English with refined expressions
• Replaced web governance interceptor with filter
• Enhanced simulation features (method-level permission checks, smart proxy lookup)
• Restructured README into bilingual format (primary English + Chinese link)

Known Limitations (Transparent)

• Current routing defaults to stable version; request dyeing (header-based precise canary routing) planned for next release
• Dashboard is an optional reference implementation; UI still needs iteration (primarily Chinese, multi-language basics supported)
• No production-scale cases or large benchmarks yet (early validation phase)
• Some edge scenarios (e.g., complex dependency conflicts) not fully tested

Get Started

See the docs:
👉 Getting Started
👉 Technical Entry
👉 Practical Entry

Interactive Documentation (AI-Generated)

Full English architecture and code explanations:
DeepWiki – LingFrame

Final Words

LingFrame will not make decisions for your system.
It only helps put things back where they belong —
while the system is still willing to be understood.

If you read this far and decide to stop,
that’s perfectly fine.

But if you choose to continue:
Feedback, issues, PRs are all welcome.
Even a simple “this looks interesting” or “this part feels off”
would be fuel for LingFrame to keep moving forward.

Thank you for reaching this point.
January 30, 2026