graph TD
A[用户请求] --> B{"代理适配?"}
B -->|"适配成功"| C[执行任务]
B -->|"适配失败"| D[记录错误]
C --> E{"循环状态引擎?"}
E -->|"停机状态"| F[自动唤醒]
E -->|"运行状态"| G[状态同步]
F --> G
G --> H[任务分派]
The control plane for 24/7 always-on agents. Turn long-horizon goals into verifiable results across Codex, Claude Code, and custom runtimes—from local SQLite to team scale.
Start with one goal. Keep long-running agent work verifiable.
Tell the Agent you already use what you want done. LoopX keeps the goal, work,
needed decisions and verifiable results durable behind the scenes, so the next
session can continue without making you learn LoopX internals first. Work with Codex, Claude Code, DeepSeek Harness and other runtimes. Advanced docs still expose the local-first architecture, ownership model and research workbench.
2. Tell your Agent the outcome. Restart your Agent host, open your project,
then send one natural-language goal:
$loopx speed up this project's slowest workflow; compare approaches and verify the gains
LoopX turns that into a visible plan, decisions that need you, and verification
as needed. Claude Code uses /loopx <complex task>; see
host setup for other runtimes. Prefer a guided first
run? Choose a task below.
📰 News
2026-10-25 · 🤝 Long-horizon agent research: collaborators welcome — Exploring breakthroughs in long-horizon outcomes under equal budgets, through feedback, replanning and reproducible evaluation on EdgeBench and real-world tasks. Academic labs and industry teams are welcome to collaborate, comparing outcomes and total cost. Discuss collaboration.
2026-10-14 · 🤖 Agentic software — Connecting goals, evidence and human feedback to engineering delivery.
2026-10-02 · 🧠 Long-horizon bootstrapping & RSI — Four months of developing LoopX with LoopX: public project history and a design perspective on system-level self-improvement.
2026-09-18 · 🧪 LoopX × LHTB — A 46-task, same-model study provides empirical support for trading more compute for better outcomes: LoopX 1.0.3 Heartbeat continued runs reach mean reward 17.3% above Plain Codex and 10.6% above native Goal.
2026-09-06 · 🎉 LoopX 1.0 — A Personal Agent Workspace to follow agent work, act on decisions, and inspect delivered results across sessions. Workspace guide.
You should not have to learn LoopX internals before the first useful action.
The default path is goal-first: describe the outcome, let the Agent prepare the
plan, and inspect the machinery only when a decision or debugging need calls
for it.
An agent can finish a task in one session. Long-running work is harder:
objectives change, owner decisions appear, evidence goes stale, and agents
hand work to peers. A timer can keep a loop running without making it useful.
Continue without starting over. Keep the Goal, accepted requirements,
decisions and evidence across sessions and restarts.
Coordinate without dropping context. Connect delegated work, dependent
artifacts, review and returned results while keeping responsibility explicit.
Judge progress by what changed. Inspect deliverables, supporting and
refuting evidence, costs and the next decision—not just activity.
Your Agent runtime supplies the model and tools. LoopX’s durable state layer
preserves goals, acceptance, decisions, ownership and evidence across sessions
and runtimes for engineering, research and operations. Agents and people use
those facts to reassess what to do next. Human authorization still governs
protected actions.
What you want to do
Start here
Keep a coding or research agent working across sessions
LoopX keeps the durable work state in one compact layer:
Agent runtimes execute the work. LoopX keeps the state that lets engineering,
research, discovery, and operations loops continue across runs. It is not
another agent framework or a provider-specific orchestration runtime.
Advanced: how the control layer works and where it fits
A useful mental model is an
agent-native Kanban for long-running work.
Cards carry identity, authority, evidence, and continuation. Moves are validated
operators such as claim, gate, monitor, and writeback. The board is a
projection; LoopX state remains the source of truth.
Registered agents are peers. Claims, leases, task boundaries, capabilities, and
typed continuation decide who acts next; no durable leader identity is
required.
LoopX is useful when you run:
multi-day engineering, research, benchmark, or experiment objectives;
issue and PR loops that must preserve scope, evidence, and review state;
recurring heartbeat or monitor work;
projects with owner, safety, publication, or private-data gates;
peer-agent teams where ownership, leases, and handoff matter;
creator, research, or operations workflows whose progress must remain
legible to a non-engineering operator.
LoopX is not an autonomous production controller. Dangerous permissions,
publishing, production writes, and final ownership stay with the human.
Open a Goal to inspect its work, responsible Agents and recorded Explore history.
Use Deep analysis to inspect a registered trajectory, its citations, native
outcome readback and separately measured costs. Research also shows source-bound
human attention,
with recorded inputs, timing coverage and inspectable optimization points. An Agent prepares the source;
opening a page or reading a result does not start a model call. Explicit analysis
uses the configured host and account.
Keep supported, refuted and unknown findings visible. Inspect why an approach
changed or continued, then carry the evidence into the next attempt.
Meet the Personal Agent Workspace
Keep long-horizon goals in one local-first workspace. Goals, attention,
conversations, tasks, files, schedules, and recovery stay durable across days,
restarts, and harnesses. Reopen a project, inspect the previous turn’s state
and evidence, and continue the next permitted action.
LoopX brings these long-horizon control states into the Personal Workspace. It gives you one place to:
see what needs you, what is running, what is being watched, and what is
scheduled or stopped;
configure Goal capabilities, distinguish machine defaults from Goal overrides,
and preview changes before applying them;
steer a live turn, queue a message, or use the async inbox from a connected
Lark conversation with explicit Goal/Agent/session routing;
inspect deliverable files, periodic reports, and their supporting evidence;
continue across Codex, Claude Code, direct-model, and other registered Agent
sessions without losing Goal state or evidence;
review protected changes through typed preview, explicit confirmation, and
receipts while LoopX state—not the browser—remains authoritative.
loopx dashboard is the supported browser/PWA launch path. You can also download
native desktop previews from the current release;
they reuse the same loopback services and Goal state. Apple Silicon macOS supports
signed App updates that pair the shell with its bundled runtime, plus repair and
recovery. Python 3.11+ is required; the App is ad-hoc signed, not notarized.
Windows NSIS preview installers support the same signed update flow on the main
channel, with a separately installed CLI; the stable channel and MSI installs stay
manual, App rollback and repair are unavailable, and the installer carries no
Authenticode certificate (Windows may show a SmartScreen prompt).
Desktop installation, updates, and source development.
Capability settings and reproducible workspace scenarios
From a source checkout, run python -m demo.workspace serve to explore a community
event, a home-energy comparison, and a neighborhood website release. Each has four
work roles, 18 tasks, two decisions, and two watches. The screenshot above comes
from this reproducible workspace. Scenarios and replay instructions.
$loopx <complex task>; activate the generated native /goal in the same session.
Claude Code
/loopx <complex task>; follow the loop driver setup for recurring work.
DeepSeek Harness
Install the native DSH plugin, select the loopx skill, then describe the task
LoopX reuses existing project state or connects the project, plans the work as
Todos and guides host activation. Ask your Agent to confirm the active Goal,
next Todo and continuation mechanism; a setup packet alone is not an active loop.
Keep the host available for continued work. loopx status shows the Goal,
decisions waiting for you and the next Todo; loopx doctor diagnoses the install.
Installing LoopX covers native Windows, pipx,
upgrades, rollback and uninstall.
Start codex in the project, then $loopx <complex task> or /skills.
Visible /goal <task_body>; no hidden headless execution by default
Claude Code
Install the opt-in adapter, then run /loopx <task> followed by /loop.
Native Claude Code /loop gated by LoopX
KunlunCode
Run loopx-kunluncode connect --project . --goal-id <goal-id> --agent-id <registered-agent-id>, add a bounded todo, then run loopx-kunluncode run --project ..
Native Goal Pro through app-server; LoopX writes completion and quota only after strict verification
OpenCode
Install the static command facade; opt in to --with-goal-bridge for recurring goals.
OpenCode command facade and explicit goal bridge
Pi
Install the opt-in goal extension with loopx slash-commands --install --surface pi, then use /loopx <task> from a trusted Pi session.
Visible Pi goal extension gated by LoopX quota (loopx_goal_activate + agent_settled continuation)
ZCode
Install the skill facade with loopx slash-commands --install --surface zcode, then invoke the $loopx skill (or /loopx <complex task>) from a ZCode session in the project.
The ZCode session’s own turn loop; every continuation enters through quota should-run
Antigravity CLI (agy)
Install the skill facade with loopx slash-commands --install --surface agy, then invoke the loopx skill (or /loopx <complex task>) from an agy session in the project.
The session’s native /goal loop (audited until <!-- GOAL_COMPLETE -->) with schedule self-wakes while the session lives; the facade instructs every turn/wake to re-enter through quota should-run — advisory pacing, not a host-enforced gate
Kiro CLI
Install the skill facade with loopx slash-commands --install --surface kiro-cli, then run /loopx <complex task> from a kiro-cli session in the project.
The session’s native /goal --max <N> <task_body> Done when: <criteria> loop, with the acceptance criteria stated inside the goal statement because the host derives them from it, bounded by the host’s own iteration budget (default 5) and settled through the built-in goal completion contract; the facade instructs every turn and iteration to re-enter through quota should-run — advisory pacing, not a host-enforced gate
loopx quota should-run # should this registered agent act now?
loopx todo claim # who owns this slice?
loopx todo update # what changed?
loopx refresh-state # what should the next turn see?
loopx quota spend-slot # account for a completed, validated slice
Clone-based install is only for contributors who want the live canary wrapper:
git clone https://github.com/loopx-project/loopx ~/loopx
~/loopx/scripts/install-local.sh
loopx doctor
First-Run Feedback
If LoopX works for you, a one-minute public issue helps us learn what a real
first run looks like. It is optional, contains no telemetry, and should not
include logs, paths, credentials, internal project names, or goal contents:
loopx first-run-report prints the same prefilled link locally without
sending anything.
Basic usage statistics default on after first-use disclosure: a daily random-ID
heartbeat for platform support and continued use, plus separate ID-free CLI
counts. No content is collected. Disable both in Settings → Capability Center
or with loopx usage-ping disable / LOOPX_USAGE_PING=0; inspect payloads with
loopx usage-ping status. See Basic usage statistics.
Evidence
LHTB: Higher Mean Reward With the Same Model
LoopX 1.0.3 Heartbeat reaches 0.4948 mean reward across 46 matched tasks:+17.3% over Plain Codex and +10.6% over native Codex Goal.
All three use GPT-5.6 Sol, max reasoning effort, and disabled Web Search.
Long-Horizon Terminal-Bench goes beyond coding: these tasks span research
reproduction, scientific simulation, multimodal analysis, professional
workflows, games, and systems work.
Execution mode
Mean reward ↑
Strict pass rate (≥0.95)
Pass rate (≥0.80)
Plain Codex
0.4218
7/46 (15.2%)
12/46 (26.1%)
Native Codex Goal
0.4475
4/46 (8.7%)
14/46 (30.4%)
LoopX 1.0.3 Heartbeat
0.4948
7/46 (15.2%)
15/46 (32.6%)
The ≥0.80 threshold is a supplementary, post-hoc view; ≥0.95 remains the
benchmark’s strict solved threshold. No score in this study equals 0.80, so
these counts also match the study brief’s >0.80 view.
Against native Goal, task-level rewards improve on 23, tie on 13, and
regress on 10 tasks. Strict solves match Plain Codex, so the mean gain is
not a claim that every task improves or that more tasks are fully solved than
Plain. Mean reward also credits partial progress.
One effective trial per task and mode; designated replacement trials and
unequal runtime/budgets, including longer budgets for some Heartbeat replacements.
These are observed system results, not an equal-budget efficiency result or
an isolated causal estimate of LoopX’s effect.
Beyond benchmarks, LoopX also has inspectable long-running project evidence.
The public OpenViking contribution sequence spans
200+ hours of elapsed loop lifetime, preserving
bounded turns, decisions, and evidence updates. This measures wall-clock project
time, not continuous model execution or unattended production autonomy. Open
the visual to inspect the public-safe task graph, evidence branches, and
cross-turn decisions; the case states its source and reproducibility boundary.
Open-Source Issue Fix
200+ hour public contribution arc: PR delivery and reusable fix knowledge
evolve together.
Contribution sources and evidence boundary
LoopX’s creator uses this path as an
OpenViking contributor.
The represented public contribution sequence spans more than 200 elapsed hours
from its first PR creation to the latest represented review or update. The
Issue-Fix capability keeps rolling
repository context, revision-stamped fix knowledge, and reviewer-facing
preferences separate; linked PRs plus current checkout source and tests remain
authoritative.
Used In Real Projects
Independent user · >13h C++ accuracy run. The user reported that a
multi-stage task stayed aligned, triggered public research, adopted a
public code-memory tool,
and improved final precision. Read the evidence boundary.
Independent user · 4d unattended run. The user reported four days
without human intervention, useful ongoing work, and a periodic report
surface. Read the redacted case.
Independent user · 7 merged PRs. A LoopX-attributed Engine refactor is
visible in a public issue and
seven merged PRs; attribution and the reported 1B+ token scale remain user
reports. Inspect the case.
Independent user · vLLM optimization merged upstream.Zheng Cai reports using
LoopX as the workflow engine for profiling, research, experiments, and
correctness checks. vLLM PR #54951
merged a sparse-indexer optimization; its reported 32.59% total-token
throughput gain is for GLM-5.3-Flash at 1M input tokens, 4×H200, TP4, C1.
Inspect the workflow, full conditions, and evidence boundary.
These are four featured independent-user cases, not the full inventory. Browse the
complete Showcase catalog for contributor cases,
creator dogfooding, reproducible demos, and explicit evidence-strength labels.
Exploratory Benchmark Studies
SWE-Marathon:
Five execution modes on 15 matched tasks compare self-verification, scores,
and cost. More self-verification did not consistently yield higher scores.
LHTB × LoopX:
The results above lead into five execution mechanisms,
task-level comparisons, regressions, and exploratory task-type analysis.
DeepSWE behavior analysis (Chinese):
Selected cases examine how domain hints relate to requirement retention and
verification choices, offering mechanism hypotheses for further testing.
SWE-Marathon and LHTB have one effective trial per task and mode; DeepSWE uses
selected cases and post-hoc analysis.
More inspectable surfaces:
the public homepage for the product
narrative, quick start, and long-running evidence;
Start with the outcome you need. Optional capabilities reuse the same Goal,
work ownership and evidence; check their support and permission boundaries.
Product Capability Paths
Capabilities turn those generic primitives into outcome-owned work lanes. Start
from the outcome, then inspect the current registered implementation and its
write boundary:
You need to…
Capability
Start with
Turn a public issue into a reviewable, evidence-backed change
loopx capability show periodic-report --format json
Run loopx capability list --format json for the authoritative catalog in the
installed release. A capability detail reports its user value, maturity,
provider readiness, entry commands, write boundaries, protocols, and durable
validation. Browse the human-readable capability index
to choose by outcome; use Extensions and Capabilities
when installing or building a provider.
Core Control-Plane Promises
The Kernel folds its mechanics into five questions. Each question delivers one
product promise on top of any agent harness: objective → long-horizon state;
next → semantic decisions; human judgment → human-agent collaboration;
evidence → recovery; continuation → governance.
Question
What LoopX keeps visible
What is the objective?
The active goal, explicit scope, and current authority.
What happens next?
Ordered user and agent todos, ownership, claims, and leases.
What needs human judgment?
Concrete user gates instead of a vague “waiting for owner.”
What evidence changed?
Compact run history, validation, blockers, and accepted writeback.
May the loop continue?
Quota, capabilities, safe fallback, scheduler hints, and stop conditions.
Architecture, control-plane surfaces and runtime responsibilities
LoopX keeps the architecture explicit so the same governed outcome can survive
a change of agent harness or external provider. The terms describe different
boundaries rather than interchangeable kinds of plugin:
Boundary
Meaning
Go deeper
Kernel
Owns durable goal, todo, gate, evidence, quota, recovery, and scheduling truth.
Host declarations such as --available-capability shell describe observed
execution support. They are runtime capacities in this product map, not product
capabilities and not permission grants. The effective capability still applies
its own policy and authority checks before proposing a transition.
Control-Plane Surface
Surface
What it does
Start with
Goal state and status
Tracks active state, todos, claims, gates, evidence, run history, and first-screen attention.
loopx status, loopx diagnose, loopx review-packet
Quota and interaction contract
Decides whether a turn should deliver, ask, wait, self-repair, or stay quiet.
Starts a live single-page panel that tracks fleet progress: sessions, their goals, and each goal’s status/todo progress, with result statistics; auto-refreshes in place.
Packages repeatable work lanes such as issue fixing, content operations, value connector planning, ML experiment advice, benchmark evidence, and Explore.
Lets named registered agents trial provider-neutral Reward Memory through ignored, default-off project configuration. OpenViking is one provider option, not a global dependency.
The shipped primitives include lifetime goals, concrete user gates, audited safe
fallbacks, peer todo ownership, quota and steering, compact run history,
evidence-backed handoff, a read-first management surface, project-level value
signals, and public/private boundary checks.
Runtime Responsibilities
Role
Responsibility
Agent
Plans, analyzes, uses tools, and performs one bounded action through a host/runtime.
Provider
Calls external systems and returns observations, effect results, and readback.
Capability
Defines the caller outcome, normalizes provider output, validates it, and proposes a typed transition.
The execution path is Agent -> Capability -> Provider; the control path
returns Provider readback -> Capability transition -> Kernel. An extension is
how an optional provider is packaged and managed, not another control-plane
owner. See Architecture and
Extensions and Capabilities.
Personal agents, teams and self-improving workflows
Personal Agents, Teams, and Self-Improving Workflows
Meta Muse
and Grok Bot make persistent personal
agents and delegated work a familiar product idea. LoopX approaches that space
as an open, provider-neutral control plane for agents you already run—not as a
hosted replacement for either product.
Personal agent: use the shipped Workspace and connected Lark surfaces to
inspect goals, steer work and resolve decisions. The
persistent steward and semantic handoff RFC
extends this toward one capable front door for a team; the complete journey
remains under qualification.
Agent team: share goals without erasing worker ownership. Claims, evidence
and explicit returns keep implementation and review connected. See the
three-agent collaboration demo
for a bounded example, including corrections and two review rounds.
Self-improving workflows: connect feedback to the next attempt through
Reward Memory, and evaluate
candidate changes through Explore.
Both are optional. The link to recursive self-improvement (RSI) is the
engineering loop—propose, test, review, retain—not a claim that LoopX has
demonstrated autonomous model improvement or compounding capability gains.
A personal steward is an interaction role, not a second source of authority.
Background execution still needs an available host and configured runtime.
The overall roadmap
separates shipped foundations from the next end-to-end acceptance milestones.
2.0 background and migration
A shared control plane
A long-horizon research workbench
TypeScript owns the migrated transactions, authority and recovery rules. Python retains real host/provider IO and specialized computation.
Follow a research question through delegated work, Explore history, artifacts, trajectory analysis and the next decision.
Upgrading from 1.x? 2.0 retires ordinary writes to unpromoted Markdown Goals.
Review the migration and recovery guide before
continuing those Goals. Installation does not silently convert existing state.
Advanced Paths
The first useful loop does not require every optional surface. Add these only
when the work needs them.
Inspect the current goal’s read-only capability catalog before enabling an
advanced path:
loopx configure-goal --goal-id <goal-id>
Without --execute, this reports current/default state, fit, boundaries, and
copyable commands without changing project state.
Recurring Work Presets
Safe presets cover daily triage, changelog drafts, and PR watching. Start with
the beginner preset guide.
loopx preset list
loopx preset show daily-triage
Preset inspection is read-only. For a connected recurring goal,
loopx ready-score --goal-id <goal-id> --agent-id <agent-id> reports whether
the loop is ready to run repeatedly.
Governed Turns
LoopX can generate one pure, bounded turn decision from a validated receipt,
fresh quota state, and a provider-neutral budget. The current Codex CLI
quickstart and activation contract are documented in
LoopX Turn for Codex CLI.
Explore Graph and Harness
Explore is supported, optional, and default-off. It works best when a task has
a measurable offline evaluation, baseline, treatment, and guardrails; it is not
a substitute for production approval. Start with the
Explore capability and its
Lark presentation mapping.
Review Agent Work
Use loopx review-packet for a compact owner-facing view of decisions,
evidence, validation, and unresolved gates. The
intelligent management surface
describes the operator model; the
project-level reward model
describes conservative value signals across output quantity, quality, token
cost, and user attention cost.
For a concrete peer workflow, start with the
Agent collaboration guide:
a builder consumes an analyst’s artifact, obtains independent review, handles
an owner correction and returns the checked result. The guide distinguishes
the runnable same-host example from the earlier cross-runtime design sketch.
Optional projections make state easier to inspect; they do not become the
source of truth.
Operating and Recovery
Start daily inspection with:
loopx status
loopx history --goal-id your-project-goal
loopx quota should-run --goal-id your-project-goal
Automatic turns must check quota first and append spend only after validated
writeback. Quiet skips, preflight failures, and dry-run previews do not spend.
When a user gate blocks one lane, a separately audited safe fallback may
continue, but it must not bypass the gate.
Peer agents use loopx todo claim before delivery and loopx todo update
after validation so ownership and evidence remain visible.
Scheduler cadence follows quota should-run.scheduler_hint; installed Codex
App automations acknowledge the current hint through the returned
ack_hint.cli_args. Collision recovery, monitor semantics, self-repair, and
the exact operator commands are maintained in
Getting Started,
Quota Allocation, and
Long-Task Cadence Policy.
LoopX has three active strategic programs plus an architecture and research
incubator. These are direction signals, not delivery promises; main, released
artifacts, and stable reference contracts remain the source of shipped truth.
Long-Horizon Benchmarks and Evidence: reproducible capability evidence
and controlled mechanism research across complementary benchmark
environments. Direction tracker
Operator Surface and IM Integration: an operator workspace, session
records, and bounded collaboration surfaces. The Personal Workspace is
shipped; unified steward, execution, and recovery journeys remain under
qualification, with @maxliux5 as implementation lead.
Direction tracker
Shared Goal Authority and Cross-host Coordination: provider-neutral
coordination for explicitly shared goals, with NoKV as an unpromoted
provider candidate rather than a new control-plane authority.
Direction tracker
Architecture and Research Incubator: Effect Program hardening,
TypeScript parity migration, hierarchical stride, research exploration,
human attention, artifact lifecycle, and memory utility work at explicitly
different maturity levels.
Direction tracker
Read the canonical
Technical Directions map for stages,
promotion gates, contributor-safe cuts, and ownership boundaries. Use the
pinned GitHub Discussion
for community discussion. Core control-plane reliability continues as the
shared foundation beneath these programs.
Start with the path that matches your current task. Use the hosted
documentation portal for the
published docs site; the documentation index remains the
complete source map. This list stays selective; each category index owns its
deeper documents and versioned protocols.
LoopX is a usable local control plane for long-running agent work and is
entering broader adoption. It is not a full agent platform, an agent runtime, or
an autonomous production controller.
Today LoopX ships a durable state kernel for goals, typed todos and decision
scopes, peer claims and leases, evidence and writeback, quota-aware scheduling,
and cross-turn continuation. Guided start, recurring heartbeat, isolated Codex
CLI turns, evidence-backed Issue-Fix admission, optional Explore and auto
research paths, public validation canaries, and the multi-project Personal
Workspace all build on that shared control state.
Support levels remain explicit. The state and CLI contracts are the stable
center; several host integrations and advanced paths are optional, default-off,
or experimental. LoopX does not grant credentials, approve destructive or
production actions, publish on a user’s behalf without authorization, or turn
an unverified run into evidence of success.
Current investment is organized through the
Technical Directions map: long-horizon
benchmark evidence, operator surface and IM integration, shared-goal cross-host
coordination, and an explicitly staged architecture and research incubator.
Community & Contributing
Help shape how long-horizon Agent teams work. Share a workflow, reproduce a
bug, build an integration, or show what your Agents accomplished. Code,
documentation, examples, reviews and carefully bounded evidence studies are
all welcome.
Discuss and share: ask questions, compare workflows and share projects in
GitHub Discussions.
Report a bug or suggest a feature: open a
GitHub Issue with
your version, host/runtime, expected behavior and a public-safe reproduction.
Make your first contribution: pick a public task from
Contributor Tasks, or bring a
self-contained fix. The contribution guide covers setup,
validation and the PR process; larger changes start with a discussion.
See Support for channel routing and official sources, and
our Code of Conduct for community participation.
Before sharing code, logs or examples
Keep .loopx/, legacy .codex/goals/, live ACTIVE_GOAL_STATE.md, raw Agent
sessions and benchmark traces, credentials, private logs, internal links,
sensitive user/team data and operator artifacts out of public contributions.
Contributors
Thank you to everyone contributing code, documentation, bug reports, reviews
and real-world feedback. You help make long-horizon Agent work easier to run,
inspect and trust.
Lark: scan to join directly WeChat: huangrt00 · mention LoopX in the friend request
Star History
Generated every six hours from GitHub's official stargazer timestamps using a repository-authorized workflow. A snapshot is published only when the fetched rows match GitHub's current star count; GitHub's image cache may delay refreshes.
Apache License 2.0 beginning with v0.4.8. See LICENSE and
NOTICE. Releases through v0.4.7 remain under their original MIT
terms; the historical text and notice are preserved in
LICENSE-MIT. The licensing policy
explains the version, contribution, patent-grant, and open-core boundaries.
You must not use AI generation, code rewriting, cross-language translation,
or project renaming as grounds to remove or evade copyright, attribution, or
NOTICE retention requirements under the applicable license. If the distributed
material is a derivative work of LoopX, those obligations still apply. This
clarification does not restrict modifications or redistribution permitted by
the applicable license. See reuse and attribution
and name and marks guidance; a derivative
distribution must not be presented as an official LoopX release.
评论