igni-core
igni is a self-hosted, air-gapped agentic platform. Its agents work in your environment, with the models you choose, on infrastructure you control, and nothing in it needs to call home. igni-core is the agent runtime at its centre: the orchestrator, the tools and the policy that governs them, and the backend the desktop app and the web client run on.
Writing and reviewing code is one thing igni's agents do, and the built-in agents are coding specialists. It is not the whole of it: an agent is a markdown file, so an organisation defines its own agents, skills, MCP servers and extensions for any team, and ships them to that team from its igni server.
Where igni-core sits
igni is several repositories, all Apache-2.0:
| Part | Repository | What it does |
|---|---|---|
| igni-core (this one) | ignite-ember/igni-core | The agent runtime and its backend: orchestration, tools, permissions, hooks, skills, MCP, extensions, sessions. Runs on a person's machine, behind the desktop app and the web client, or headless as the igni command. |
| igni server | ignite-ember/igni-server | Self-hosted, and runs with no internet access. Identity (sign-in, OIDC, SCIM, organisations), inference routing and the model key pool (your GPU nodes or any OpenAI-compatible endpoint, Anthropic, AWS Bedrock, Vertex AI, Azure OpenAI and Microsoft Foundry, with the server holding the cloud credentials), the extensions approved services ship, group policy, and the audit trail. |
| igni app | ignite-ember/igni-app | The desktop app (Tauri) and the web client: one web UI, where people chat with agents, approve what they do, and use extensions' pages. |
| SDKs | ignite-ember/igni-sdk | igni-service (an extension's backend service), igni-extension (an extension's process), igni-client (a program driving an igni), @ignite-ember/extension-bridge (an extension's page), @ignite-ember/ui-react and @ignite-ember/ui-css (its UI). |
Paid modules (CodeIndex, Artifacts, Fleet) are separate products that plug in through the same extension and service-identity interfaces. igni-core runs no graph database or embedder of its own.
What igni-core gives you
- Multi-agent orchestration. An orchestrator reads each task and assembles a team from the agent pool, in one of four team modes (route, coordinate, broadcast, tasks). Any agent may spawn a sub-team, within configurable depth limits, agent caps and timeouts. Agents, Architecture.
- Tools under a permission system. Every tool call is checked against
allow/ask/denyrules and a permission mode (default, accept edits, plan, bypass,dontAsk). Adenyrule holds in every mode, and an organisation's managed settings set a floor no user flag gets past.--read-onlyruns only reads;--strictdenies anything without an explicit allow rule. Protected paths and dangerous command shapes are blocked. Security, Tools. - Workspace trust. Opening a folder never runs its code: until you trust it, its tools, hooks, workflows and permission settings stay off. Workspace trust.
- Hooks. Commands or HTTP calls on agent lifecycle events, which can
block, change or record a tool call. Hooks your organisation ships run
only as your
hooks.groupsetting allows. Hooks. - Skills. Reusable workflows as
SKILL.mdfiles, invoked by slash command or picked by the orchestrator. Skills. - MCP. igni is an MCP client over stdio and SSE; servers' tools reach the agents you allow them for. MCP.
- Extensions. A capability with a service behind it: tools over MCP,
its own page in the app, hooks and host access, each declared in a
manifest an administrator approves. The extension's process runs in an
OS sandbox (Seatbelt, bubblewrap, AppContainer) that reaches only its own
service and declared hosts. A bundle igni server distributes is installed
only if its signature verifies against the service a super admin
approved; anything else is a development install behind
IGNI_DEV_EXTENSIONS=1. Extensibility, Plugins. - Sessions and memory. Sessions, scheduled tasks and memory are kept in
local SQLite, or in PostgreSQL through the
igni-cloudpackage andstorage.database_url. Resume with-cor--session-id. Architecture. - Organisation policy. igni server publishes a signed policy pack per group (settings, agents, hooks, MCP servers); igni verifies the signature, issuer, person and version before merging any of it. Group policy.
- Any model. A model registry with three providers:
openai_like(any OpenAI-compatible API: vLLM, llama.cpp, Ollama, OpenAI, Groq, …),anthropic(Claude, or an Anthropic-compatible gateway) andgemini. Or the models your igni server serves, with no key on the laptop. Configuration. - Air-gapped operation. One switch,
air_gapped: true, stops every outbound connection igni makes on its own. Running air-gapped. - Auditability. A JSON-lines audit log on the machine
(
~/.igni/audit.log), OpenTelemetry traces and metrics to your own collector (each agent run, model call and tool call, with igni's permission decision; prompts and code left out by default), and the organisation's append-only audit trail in igni server. OpenTelemetry. - Verifiable releases. Every release carries SHA-256 checksums, CycloneDX SBOMs and build-provenance attestations you can check on a machine with no network. Verifying a release.
Quick Start
brew install ignite-ember/tap/igni-core # or: pip install igni-core, or: uv tool install igni-core
cd your-project
igni --read-only -m "In one sentence, what does this project do?"
igni is the command, and the only one pip, uv and the Homebrew formula
install. igni is supported on Apple Silicon macOS and x86-64 Linux: it
searches code with ripgrep: the formula brings Homebrew's, pip
and uv bring the PyPI package on macOS arm64 and Linux x86_64, and
elsewhere you install rg yourself (brew install ripgrep, sudo apt install ripgrep) — see Quickstart. On the command line it runs one task and exits (-m, or -p for a
pipe); there is no terminal chat UI any more — run it bare and it says so.
The interactive chat is the desktop app and the web client.
What the published package holds today. igni-core on PyPI is
v1.0.5, and it is this repository's build: the igni_core module,
the igni command and the decisions service, and the Homebrew formula
installs the same package. The old name, ignite-ember, is retired: its
releases are yanked from PyPI and there is no formula or command by it.
Why --read-only. A headless run cannot ask before it runs a command,
so decide up front what it may do. igni reads files with the shell, which
asks by default, so without --read-only the question above stops at its
first cat with "Run paused for confirmation" and exits 1 — see
A headless run cannot ask you anything.
The first run in a folder also asks whether to trust it, and writes
igni.md and .igni/ there.
To work on igni-core instead of installing it:
git clone https://github.com/ignite-ember/igni-core.git
cd igni-core
uv venv && uv pip install -e ".[dev]"
source .venv/bin/activate # puts `igni` on your PATH
Configuration
Settings merge, strongest first, from the managed-settings file (which a
user cannot override), your organisation's group policy, command-line
flags, a project's .igni/config.local.yaml and .igni/config.yaml
(once you trust the folder), and your ~/.igni/config.yaml.
Configuration has every key.
Connecting to igni server. To point it at your own igni server, set api_url in your user config,
~/.igni/config.yaml — not a project's .igni/config.yaml or
config.local.yaml, which may not name a server and are ignored for it,
with a warning — and run igni login (or igni login --token-stdin with a
token). That writes ~/.igni/credentials.json, which igni -m and the desktop
app both use. /login is not a shell subcommand: igni /login answers
Error: No such command.
# ~/.igni/config.yaml
api_url: https://igni-api.acme.example
# Only when the portal (the sign-in page) is not on the API's origin,
# e.g. the API on :7777 and the portal on :3000:
portal_url: https://igni.acme.example
portal_url is worked out from api_url when both run under one name and
differ by a host label (api.acme.example → acme.example); set it when
they differ any other way, such as by port, or sign-in opens a page the API
does not serve. Signed in, the models your server serves join the registry
with api_key: cloud_token, a token igni sends only to that server's
origin. There is no default server: until you set api_url, igni contacts
none.
Bringing your own model. Add it to the registry. The endpoint can be a model server inside your network:
# ~/.igni/config.yaml
models:
default: local-coder
registry:
local-coder:
provider: openai_like # vLLM, llama.cpp, Ollama, or any OpenAI-compatible API
model_id: qwen2.5-coder-32b
url: http://vllm.acme.internal:8000/v1
api_key_env: VLLM_API_KEY # or api_key, or api_key_cmd: "op read ..."
See Model registry for the
anthropic and gemini providers, and
Cloud models through igni server
for Claude on Bedrock or Vertex AI and models on Azure OpenAI.
Running air-gapped
Set the switch in ~/.igni/config.yaml, in the managed-settings file
(/etc/igni/managed-settings.yaml on Linux,
/Library/Application Support/igni/managed-settings.yaml on macOS,
%PROGRAMDATA%\igni\managed-settings.yaml on Windows), in a group's policy,
or with IGNI_AIR_GAPPED=1:
air_gapped: true
network:
internal_hosts: ["git.acme.internal", "*.svc.acme.internal"]
With it on, igni makes no connection outside your network on its own:
- no update check to PyPI; the desktop updater uses only your
update_endpoint, if you set one; - web search and URL fetch are not built at all;
- plugins, extensions, MCP servers reached by URL, HTTP hooks and an
OpenTelemetry collector are allowed only on hosts inside the network —
loopback, local paths, the hosts of
api_url,portal_url,update_endpointand your plugin marketplaces, andnetwork.internal_hosts; - the local decision model is loaded only from a pre-seeded cache, and the
desktop app downloads no runtime: it runs on the
runtime_pythonyou provision; - Agno's telemetry is off, even if
AGNO_TELEMETRY=trueis set.
A project's own config cannot switch it off or name a host as internal.
What the switch does not cover: programs the agent runs (curl, pip,
git), MCP servers started as local processes, command hooks, and the model
endpoints you configure. Run igni behind a deny-all egress rule for those.
Without the switch, an unconfigured install contacts no vendor service: the
only connections it makes on its own are the daily PyPI update check
(update_check_ttl: 0 turns it off), the desktop app's updater and
first-launch runtime download, and the decision model's first download.
Web search and URL fetch ask each time.
Outbound connections by default
lists each one, and tests/test_an_air_gapped_install_makes_no_outbound_call.py
proves each row.
Air-gapped mode covers providing the desktop runtime and pre-seeding the decision model. For the server side, igni server ships each release as one signed offline bundle (Offline updates, Air-gap rehearsal, Self-hosting).
Clients
igni ships the desktop app (Tauri), the web client and the CLI. The desktop
app and the web client share one web UI, both in
igni-app; the desktop app spawns
this backend and talks to it over a loopback WebSocket
(python -m igni_core.backend --ws-port 0) that checks the page's origin
and a per-launch token. In a terminal, igni -m and igni -p run one task.
Documentation
Start here
- Quickstart — install, first run, permissions for a headless run
- Configuration — settings tiers, the model registry, igni server, air-gapped mode, telemetry
- Security — threat model, permission system, protected paths, outbound connections, enterprise hardening
- Architecture — the process split, the request lifecycle, sessions
Agents and what they use
- Agents — agent definitions, the orchestrator, team modes, sub-teams
- Tools — the toolkits and which agent gets which
- Skills — reusable workflows invoked by slash command
- Hooks — lifecycle hooks, including your organisation's
- MCP — connecting MCP servers
- Plugins — Claude-Code-compatible bundles of skills, agents, hooks and MCP servers
- Onboarding — what the first run in a folder sets up
Extending igni
- Extensibility — the contract extensions build against: manifest, permissions, sandbox, trust
- Your first extension — from an empty directory to a running extension (in igni-sdk)
- Host object model — what an extension's process and page may reach
- Design system — the UI an extension's page is drawn with (in igni-app)
Releases and assurance
- Verifying a release — checksums, SBOMs, build provenance, online and air-gapped
- Vulnerability management — what is scanned, what gates a release, remediation targets
- Reporting a vulnerability — where to send it, and what happens next
Working on igni-core
- Contributing — how to send a change, and the Developer Certificate of Origin
- Development — project structure, setup, the Makefile
- Testing — running the suite
- Evals — the agent evaluation framework
- Benchmarks — a 12-case software-engineering benchmark
- Migration — coming from Claude Code or Codex
- Platform plan and Build plan — what is still to be built, in order
Security
igni-core runs on a person's own machine and executes what agents decide, so its defences are local: the permission system, workspace trust, protected paths, the extension sandbox, and an origin check plus a per-launch token on the backend's WebSocket. docs/SECURITY.md is the threat model. Report a vulnerability as SECURITY.md says, not in a public issue.
Releases are built by .github/workflows/release.yml and published to PyPI
with trusted publishing (PEP 740 attestations). Each GitHub release carries
SHA256SUMS, CycloneDX SBOMs and Sigstore build-provenance bundles;
Verifying a release shows how to check them,
including on an air-gapped machine. A cosign signature over SHA256SUMS
follows once the release key exists.
Contributing
See CONTRIBUTING.md. Every commit carries a
Developer Certificate of Origin sign-off (git commit -s).
License
Apache 2.0 — see LICENSE and NOTICE.
Upgrading
The VS Code and JetBrains extensions are no longer shipped or supported; release notes below that mention them are history.
Unreleased
- The
ignite-embername and command are retired. The package isigni-coreand the command isigni; nothing is published or installed under the old name any more. Everyignite-emberrelease on PyPI is yanked, theignite-emberconsole script is gone from the package, and the Homebrew tap has a single formula,igni-core—ignite-ember/tap/ignite-emberno longer resolves. Install withpip install igni-core,uv tool install igni-coreorbrew install ignite-ember/tap/igni-core; a script that runsignite-emberhas to runigni. pip install igni-coreworks where PyPI'sripgrephas no wheel. Theripgreppackage is required only on macOS arm64 and Linux x86_64, the platforms it ships wheels for; its sdist needs Rust, so on Linux arm64 and Intel macOS the install used to fail. AnrgonPATHis always used first; the package's binary is found even when the venv is not onPATH(auv toolinstall, the desktop app) and is put on the agent shell'sPATHafter the user's own. With norgat all, code search falls back to a slower walk and the log says how to install ripgrep (brew install ripgrep,sudo apt install ripgrep).
The split release (v1.0.3 → v1.0.4)
igni-coreis on PyPI. v1.0.4 is the first release published under igni's own name:pip install 'igni-core[decisions]==1.0.4'installs theigni_coremodule, theignicommand and the decisions service. Theignite-embername that 1.0.4 also shipped as an alias is retired since: its PyPI releases are yanked, and the Homebrew formula isigni-core.- The cloud layer is its own package.
igni-cloudholds the PostgreSQL storage and the producer/guest binding, found through theigni.layersandigni.storageentry points, rather than inside the core. - The wire contract is typed. The messages the backend and the app exchange have one definition, checked from both sides — the app's client is igni-core's contract, byte for byte.
- One module per concern. The backend is split into modules that each own one thing — settings, auth, the cloud, the tools, the transport — behind interfaces the tests can substitute. Nothing reaches into another's internals.
igni loginis a command. It opens the portal's sign-in page in a browser, takes the token back over a local callback, writes~/.igni/credentials.jsonand hydrates the group pack.igni login --token-stdindoes it without a browser.- The Windows sandbox is behind one interface. What it allows is one thing to state, and one thing to test.
- An install made under the old name keeps working. The desktop app still reads the cache directory and the install marker under their old names until the next write, so an app installed before the rename does not reinstall its runtime.
Rebrand + signed desktop app (v0.7.0 → v0.7.1)
- Rebrand to
igni. Shorter, single-word product name — the Tauri window, the macOS Dock, the VSCode + JetBrains marketplace listings, the welcome screen, the agent's self-identification all readigni. Internal identifiers (PyPI packageignite-ember, Python moduleigni_core, Tauri bundle idsh.ignite-ember.desktop, VSCode/JetBrains plugin slugs) are preserved so existing installs keep auto-updating without breakage. igniCLI alias. The terminal command is nowigni(the oldignite-emberinvocation kept working through v1.0.4 and is retired since).- Apple Developer ID signing + notarization on the macOS desktop app. First-launch no longer triggers the "unidentified developer" Gatekeeper warning; the notarization ticket is stapled into the
.appso offline first-launch works too. The auto-updater pulls a fully signed + notarized bundle. - Mermaid diagrams in the chat. Fenced
```mermaidblocks render as SVG (sequence / flowchart / state / ER / pie / gantt / mindmap / xy-chart / quadrant / timeline). Mermaid lazy-loads — first diagram in a session triggers the download. - Collapsible code blocks. Anything taller than ~220px starts collapsed behind a chevron with a fade overlay; click anywhere on the clip (or the chevron) to expand. Copy chip stays always-visible top-right.
- GitHub-Light syntax colors on light theme. Stops the dark-dimmed
highlight.jspalette from painting neon-on-white when the user picks the light theme. - Per-turn stats restored on resumed conversations. Re-opening a session now shows the same
✦ in · think · out · durationpill the live path emits — chars/4 estimates pulled from each persisted run's content (Agno's rawinput_tokensreads non-monotonic across iterations and was useless to restore literally). - Header drag-region fix. The first user message's edit / delete chip is no longer captured by the Tauri shell's window-drag region — clicks reach the buttons.
- Updater signature bug fixed (v0.7.1). The macOS auto-updater's tarball-signature pair now matches at the asset level: stapled bytes are uploaded under the arch-suffixed name
latest.jsonreferences, so signature verification succeeds. Anyone who installed v0.7.0 before this fix should update to v0.7.1 — the auto-updater itself will pull it through cleanly.
GUI clients (v0.6.0 → v0.6.4)
- Tauri desktop app. Native window hosting the shared web UI; spawns the Python backend over a Unix socket, kills it on app exit (with
IGNI_PARENT_PIDwatchdog for crash safety). macOS / Windows / Linux installers from CI; signed auto-updater backed by minisign. - VSCode extension. WebView hosting the same shared UI; activates on workspace open with one command. Auto-installs
ignite-emberviauvon first run — zero-touch. - JetBrains plugin. JCEF panel hosting the same UI. Plugin SDK build wired into the release pipeline; published to the JetBrains Marketplace.
- Shared web UI.
clients/webis the single React+TS surface; the three shells embed it. Single bundle, single React tree, single CSS — visual + behavioral parity across the three hosts. - Backend multi-session reliability. SQLite hardening (WAL + checkpoint tuning), idle session eviction, slow-client back-pressure, sync-in-async call-site audit. Removes the long-running-session memory-leak class.
- Release pipeline matured. Marketplace publishing for VSCode + JetBrains; signed Tauri updater via minisign; per-tag draft → publish flow that avoids race-y duplicate releases under parallel matrix uploads. Pre-release tags (
-rc) skip marketplace pushes + Homebrew updates so iteration doesn't pollute user-facing channels. - UI polish (v0.6.1). Header / sidebar use a backdrop blur stack so messages frost as they scroll under; custom scroll-indicator thumbs (the native scrollbar would have rendered inside the blur layer); dark-theme icon variants.
v0.5.0 is the "Beat Claude Code" release. Cumulative changes since v0.3.8:
Benchmarks vs Claude Code (new in v0.5.0)
- Head-to-head benchmark suite. 12 cases × 5 runs vs Claude Code on the same target codebase. Programmatic deterministic grading. igni wins 49 / 60 ✅ vs 31 / 60 ✅ at one-eightieth of the per-run cost. Full breakdown in docs/BENCHMARKS.md.
- CodeIndex-first specialist agents. New
*.codeindex.mdvariants forarchitect,debugger,explorer,reviewer,security,simplifier— each with prompts tuned to query the index first instead of grepping. Auto-selected when a populated CodeIndex exists for the current commit. - Mandatory "What already exists" preamble. The main-agent prompt now requires every code-write response to start with a four-bullet section naming (a) the reuse target, (b) the closest near-miss it considered and rejected, (c) the conventions to match, (d) the parallel infrastructure it will not introduce. Forces contrastive reasoning before code is written.
- Encapsulation rule. When a service class wraps a resource (db client, cache, queue, storage), new code must call methods on that class instead of inlining the raw client. Catches the "copy a private prefix into a new file and instantiate the client myself" anti-pattern.
Plan-and-Align workflow (v0.4.2)
- HITL approval for complex action work. Main agent now plans first and waits for user approval before executing non-trivial tasks. Read-only review/audit work bypasses this and goes direct to the agent loop.
- "Working with the User" framing. Prompt restructured around "the human owns the bigger picture" — agent surfaces trade-offs, asks when uncertain, takes pushback seriously instead of defending its plan.
- Strengthened safety rules. Explicit handling for
.envfiles, raw SQL, destructive shell commands, and blind-edit prevention. - Eval framework rebuilt. Per-case Session isolation, per-case timeout overrides,
tool_arg_assertions(e.g. assertsspawn_team(mode="...")),prior_messagesfor multi-turn cases, work-dir-aware file assertions. New eval suites for bulk_edits, file_safety, mcp, team_modes, team_tasks, knowledge_corner, knowledge_proactive, memory_knowledge, multiturn, error_recovery, long_running, schedule, web_discipline, background_notifications.
Async shell + background notifications (v0.4.1)
- Pure async shell tool.
run_shell_command/read_process_output/watch_process/stop_process/list_processesare nowasync defusingasyncio.create_subprocess_exec. Previously blocked the event loop for up to the timeout (and a hard 3s on everybackground=Truecall), starving the HITL multiplexer drain and the FE message stream. - Background-process completion notifications. When a backgrounded shell command finishes, the agent receives a queued
BACKGROUND PROCESS COMPLETEDnotice with the output tail; the TUI also gets aPushNotification. - Idempotent
read_process_output. Multiple reads with different tails work; eviction moved to a 10-min TTL after the most recent read. - Schedule eval suite. 12-case suite verifies the agent reaches for
Scheduleexactly when the user describes deferred/recurring work — and not otherwise. Achieves 12/12.
Sub-agent HITL + run resumption (v0.4.0)
- Sub-agent HITL bridge. Specialist sub-agents (e.g. architect) can now request user confirmation through the same TUI flow as the main agent. Multiplexer was extracted from
run_messageandresolve_hitlso parent pauses no longer drop the specialist's pause requirements. acontinue_run"No runs found" fix. Session DB is now threaded into pool specialists and theTeam(...)constructor so paused runs are persisted and can be resumed.- Concurrent-spawn race fix. Per-spawn
copy.copy()of pool specialists inspawn_agent/spawn_team. Without this, two concurrent spawns of the same specialist raced on sharedAgentper-run state and Agno errored with "No runs found for run ID". - BE/TUI cleanup robustness. Signal handlers,
atexit, process-group kill, and anIGNI_PARENT_PIDwatchdog. Closes the runaway-BE failure mode where the TUI crash left a zombie backend. httpxtimeout actually applied. Was previously shadowed by the SDK timeout when anhttp_clientwas provided.- Eval harness. Auto-approve HITL drain,
--case-timeout(default 60 s),--case-retries(default 2),--spawn-timeout,retries=0for determinism, WebSearch stub, ENV vs FAIL output classification, default concurrency 5. - New tests.
test_subagent_hitl_e2e(8 cases, bridge in isolation),test_orchestrate_real_agno(real Agno Agent + AsyncSqliteDb). - 1363 tests pass.
Earlier v0.3.x fixes still relevant
v0.3.8 includes the following changes:
- Problem: Escape key did not close the MCP panel (
/mcp) or the task panel.- Solution: Added all dialog/panel widgets to the Escape handler, including MCPPanelWidget and TaskPanel.
v0.3.7 includes the following changes:
- Problem: Edit/Write/Bash tools never asked for user confirmation, even when permissions were set to "ask".
- Solution:
requires_confirmationflag is now set on each function after registration in all custom toolkits.
- Solution:
v0.3.6 includes the following changes:
-
Problem: Debug logs grow unbounded and can fill up disk space.
- Solution: Switched to RotatingFileHandler with 10MB limit and 2 backup files.
-
Problem: Shell command output can be extremely large, causing issues when sending to the LLM.
- Solution: Truncate tool results to 30,000 characters, keeping start and end of output.
-
Problem: TUI escape key only closes the login dialog, leaving other panels open.
- Solution: Now closes any open panel: login, help, model picker, or session picker.
-
Problem: Learning features get stuck and never complete (caused by httpx connection pool issues in threads).
- Solution: Run learning extraction as an async task on the main event loop instead of a separate thread.
To upgrade igni to the latest version:
brew upgrade ignite-ember/tap/igni-core
If brew upgrade doesn't work or you encounter issues, manually reinstall:
brew uninstall igni-core && brew untap ignite-ember/tap && brew install ignite-ember/tap/igni-core
Metadata
Release files for igni-core 1.0.5
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| igni_core-1.0.5.tar.gz | 4.9 MB | With provenance | Details for igni_core-1.0.5.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| igni_core-1.0.5-py3-none-any.whl | Python 3 | none | any | Details for igni_core-1.0.5-py3-none-any.whl |
Total release size: 7.3 MB
Release files / igni_core-1.0.5.tar.gz
| Download URL | igni_core-1.0.5.tar.gz |
|---|---|
| Size | 4.9 MB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
d73557bcb45b82aab73cd42c54161e5588193629c620fd61bd1470ddefd172d4
|
|
BLAKE2b-256 checksum How to use checksums |
d695af27f5105bb21831c478708b9b57e041ff129d50cdb38ee34cb3307f1139
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.
Transparency logRelease files / igni_core-1.0.5-py3-none-any.whl
| Download URL | igni_core-1.0.5-py3-none-any.whl |
|---|---|
| Size | 2.4 MB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
37ef71be276040125104381d882980815c7646a3b29144e30c0a6af371c8c27b
|
|
BLAKE2b-256 checksum How to use checksums |
af4b24a722bc295a6ca26d3f76cf09d44e9246ea94a400801ea6ba6e97aab0c8
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/7.0.0 CPython/3.13.16
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.
Transparency logSecurity for igni-core 1.0.5
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
Full provenance
Both files in this release have been uploaded with provenance metadata.
Attestation for igni_core-1.0.5.tar.gz
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Nov 17, 2026.
Transparency logA note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.