Try in the browser
For anyone, nothing to install. Needs: none.
The engine runs locally as WebAssembly; nothing is uploaded.
One Rust engine for GNSS (Global Navigation Satellite System) and PNT (positioning, navigation and timing) resilience: a command-line interface (CLI), Rust, Python and JavaScript packages, Kshana Studio in the browser, a JetBrains IDE (integrated development environment) plugin and an MCP (Model Context Protocol) server, so an AI (artificial intelligence) assistant runs the validated engine instead of guessing the maths. Open source under the AGPL-3.0 (GNU Affero General Public License, version 3) or a commercial licence.
The recorded session plays here with JavaScript.
Generated from the repository's manifests and cross-checked against its READMEs, so every command matches v0.41.0. kshana-mcp gives your AI assistant the same engine: a TOML (Tom's Obvious, Minimal Language) scenario in, JSON (JavaScript Object Notation) and CSV (comma-separated values) out.
For anyone, nothing to install.
The engine runs locally as WebAssembly; nothing is uploaded.
For engineers who want the kshana command.
Then check itkshana --version
For analysts and notebooks.
Then check itpython -c "import kshana; print(kshana.version())"
For anyone using an MCP-capable assistant.
Then check itcargo install --list | grep kshana-mcp
Registry name io.github.ashfordeOU/kshana-mcp. Register it with your client, from the kshana-mcp README:
{
"mcpServers": {
"kshana": {
"command": "/Users/you/.cargo/bin/kshana-mcp",
"env": { "KSHANA_MCP_IQ_DIR": "/Users/you/iq" }
}
}
}{
"mcpServers": {
"kshana": {
"command": "/Users/you/.cargo/bin/kshana-mcp",
"args": [],
"env": {}
}
}
}For no Rust toolchain; the MCP server in a container.
Then check itdocker image inspect ghcr.io/ashfordeou/kshana-mcp:0.41.0 --format '{{.Id}}'
For Rust developers embedding the engine.
Then check itcargo tree --depth 1 | grep kshana
For IntelliJ, PyCharm and CLion users.
Settings → Plugins → Marketplace → search "Kshana" (plugin ID dev.kshana.ide). Right-click a scenario .toml and choose Run Kshana Scenario.
Rust engineAGPL-3.0 or commercial licenceSoftware bill of materials and build provenance on every release
The recorded session plays here step by step.
Same run in the Studio: Engine v0.41.0 · clock-holdover.toml · seed 42Open in Kshana StudioReport
53 tools over the public Kshana API (application programming interface), in the official MCP registry as io.github.ashfordeOU/kshana-mcp. Orbit exports: SP3 (Standard Product 3) and CCSDS (Consultative Committee for Space Data Systems) OMM and OEM (orbit mean-elements and ephemeris messages, TEME: True Equator, Mean Equinox frame). Register it under AI assistant (MCP server) or Docker image. MCP server docs
run_scenarioRun a Kshana PNT-resilience scenario from a TOML definition and return its figures of merit. Returns the human-readable summary followed by the full result JSON (FoMs, curves). Kshana validates SGP4/SDP4, IAU reference frames, Allan deviations, GNSS availability/DOP, ARAIM protection levels, GNSS/INS fusion, and quantum-sensor models against published references. Every kind runs through this one tool, including spectrum (radio-frequency spectrum and waterfall), solar-system, constellation-design and body-pnt (constellations around any body), campaign (chained phases, parameter sweeps, Monte Carlo ensembles and composed scenarios) and the low-Earth-orbit navigation kinds leo-signal, leo-pass, leo-navmsg, leo-pvt, leo-ppp, ntn-positioning and leo-pnt-chain. Content is inline: a scenario field that names a file is refused, and a scenario is at most 4 MiB. Call list_scenario_kinds first to discover scenario types and their fields, and list_example_scenarios / get_example_scenario for a complete runnable scenario of a kind.
list_scenario_kindsList every built-in Kshana scenario kind with its description and required/optional TOML fields, as a JSON array. Use this to discover what scenarios can be run and how to construct a valid scenario TOML for run_scenario.
validate_scenarioPre-flight check of a Kshana scenario TOML: verify it parses as TOML and detect its scenario kind, without running it. Returns the detected kind, or a descriptive error for malformed TOML. (run_scenario performs the full validation by executing the scenario.)
assess_receiver_logAssess a real GNSS receiver log for trust: read a u-blox UBX, RINEX 3 (optionally with broadcast navigation, which adds the engine's own fix, RAIM and a clock-aided monitor), Android GnssLogger or NMEA log, run the trust monitors (carrier-to-noise density drop, AGC, jamming indicator, loss of lock, position jump, RAIM, clock) against a calibration baseline, and return when and why the receiver stopped being trustworthy. Optional [[events]] with onsets and predicted C/N0 drops are scored against tolerances stated in the scenario: detected, late or missed, and agree or disagree. Returns the summary and the full result JSON (chart and CSV on request; a vessel run's CSV begins with a # comment line carrying the advisory statement, which CSV readers skip with their comment option). The log's bytes go inline in the TOML as text or base64 (inline only, at most 4 MiB). A [platform] kind = "vessel" table selects the maritime monitors (kinematic consistency, heading against course, speed log, antenna height, C/N0 spread, time consistency) and adds a 0-100 trust score per epoch with the monitors that deducted. Every epoch also carries its satellite geometry (good; degraded for few satellites or high PDOP or HDOP; or unknown where the log has no satellite elevations or DOP); every epoch has a label (good, fair, poor); for a vessel a geometry monitor joins the score, deducting only when the geometry is poor (at most 15 points: degraded, never untrusted), and every deduction carries a class: geometry (the sky), environment or inconsistency (attack-like). For a stream excerpt with the gate use assess_vessel_stream. Advisory only; evidence tier MODELLED.
list_example_scenariosList the bundled reference scenarios as JSON: count, and scenarios, an array of name, kind and about (the first sentence of the file's own header comment). Every one is a complete scenario that runs as it stands, so this is the quickest way to a valid TOML for a kind: pick a name, fetch it with get_example_scenario, edit it, run it. Pass kind to list only the examples of one kind (for example spectrum, solar-system, constellation-design, campaign, leo-signal, leo-pass, leo-navmsg, leo-pvt).
get_example_scenarioReturn the TOML text of one bundled reference scenario, byte for byte the file the repository ships under scenarios/. Pass the text (edited or not) to run_scenario, report_scenario, animate_scenario or an export tool. Names come from list_example_scenarios. A scenario that exists in the repository but is not bundled is refused with the reason.
report_scenarioRun a Kshana scenario and return its report: an executive summary, the inputs, every result figure with its unit and its VALIDATED or MODELLED label, the events, the capability rows the run exercised, and a reproducibility record (engine version, scenario and result SHA-256 digests, seed, the command that reproduces it). format is json (default; the machine-readable report.json) or html (the printable, self-contained report.html with the chart embedded). A campaign's report also carries its sweep table or Monte Carlo distribution. The report is a pure function of the scenario: no clock is read.
animate_scenarioRun a Kshana scenario and return its time series as an animation. format is svg (default: one animated SVG, no script), html (one self-contained player page) or frames (numbered static SVG frames plus manifest.json, at most 120 frames in a reply). Optional fps (1 to 60, default 12), duration_s (0.5 to 600, default 8) and width (480 to 3840 pixels, default 960). The first content item is a JSON summary of what was drawn: the time range and unit, the chart titles, the number of phases and events, whether a spectrum waterfall is present, the result paths the traces were read from, any series left out, and the file names. The files follow, one content item each, in the order the summary's files lists them. A kind whose result has no sampled time axis is refused with a message that says so. The animation is MODELLED presentation of the run's own numbers; the same scenario and options give byte-identical files.
list_export_formatsReport which interoperability export formats apply to a Kshana scenario, without running it: a JSON array with one entry per format (czml, kml, geojson, stk, sigmf) giving applies, the reason when it does not, and spec_url, the published specification the writer follows. CZML (Cesium Language), KML (Keyhole Markup Language), GeoJSON and the STK (Systems Tool Kit) ephemeris .e describe the scenario's geometry; SigMF (Signal Metadata Format) records the samples a spectrum scenario with an [iq] block synthesises. Call this before export_interop.
export_interopExport a Kshana scenario in one interoperability format: czml (Cesium Language, for CesiumJS), kml (Keyhole Markup Language, for Google Earth and geographic information system tools), geojson (RFC 7946), stk (Systems Tool Kit ephemeris .e, one file per satellite) or sigmf (Signal Metadata Format recording of a spectrum scenario's synthesised samples). The first content item is a JSON index: format, spec_url and files, each with its suffix (what the command line appends to the output name, for example .czml or .G01.e), bytes, sha256 and encoding. The files follow, one content item each, in index order: utf-8 files as their text, the binary SigMF sample file as base64. A campaign exports each member scenario the format applies to. A format that does not apply is refused with the reason; list_export_formats reports all five at once. Times are Coordinated Universal Time (UTC); the same scenario gives byte-identical files.
import_routeWrite a GeoJSON route into a Kshana scenario that flies a waypoint track, and return the new scenario TOML (run it with run_scenario). The route is a LineString (or a Feature / FeatureCollection holding one) of longitude, latitude positions; it replaces the scenario's start_lat_deg, start_lon_deg, step_lat_deg, step_lon_deg and waypoints. The kinds that take a route are terrain-nav, terrain-slam, gravity-map and combined-altpnt; any other kind is refused with the reason. Give the two ends of the track, or evenly spaced positions along a straight line: the track kinds fly start + i*step, so any other shape is refused.
export_sp3Export an orbit scenario's propagated constellation as SP3-c precise-ephemeris text (the standard GNSS post-processing format). Errors if the scenario is not an orbit kind.
export_ommExport an orbit scenario's mean elements as a CCSDS 502.0-B-2 OMM (Orbit Mean-Elements Message) catalogue — one OMM per satellite. Errors if the scenario is not an orbit kind.
export_oemExport an orbit scenario's propagated constellation as CCSDS OEM 2.0 ephemeris text — the inertial (TEME) state time series carrying position AND velocity, which flight-dynamics tools (GMAT / Orekit / STK) read. This is the velocity-carrying complement of the position-only export_sp3. Errors if the scenario is not an orbit kind.
export_table_csvRun a Kshana scenario and return its reproducibility table as CSV text — the byte-stable table the CLI writes as <scenario>.table.csv and the papers cite. Only these kinds emit one: realtime-frame-eop, lunar-time-budget, lunar-jamming, telecom-timing, leo-navmsg when its encode-decode analysis runs on a kepler16 or kepler-rac message model (the broadcast ephemeris table), and moonlight-service-volume when both export_site_lat_deg and export_site_lon_deg are set. Errors for any other kind (or an invalid scenario); use run_scenario for the figures of merit.
sky_geometrySky geometry under an azimuth-dependent skyline (a street canyon, a harbour, a fjord, a container terminal): from a site, a time and constellation presets, two-line element sets (tle, with a UTC epoch) or satellites given as azimuth/elevation or ECEF, which satellites are visible and which are hidden by the skyline, GDOP/PDOP/HDOP/VDOP/TDOP from the gnss_lib_py-checked DOP kernel, the east-north-up cofactor and covariance with one receiver clock per system (or one in common), and the horizontal error ellipse at one sigma and at a stated confidence for a stated UERE. With no request, describes a REPRESENTATIVE skyline preset with its provenance and its cut every degree (an empty skyline_preset lists them). Scenarios of the orbit and integrity (with user_site), gnss-sim, jamming, leo-pvt and leo-pass kinds take the same [skyline] section through run_scenario. Evidence tier MODELLED: geometry under a stated error model, line of sight only; not a prediction of a receiver's real error and not an integrity bound; preset constellations are a representative sky, not the sky of a date; tle text with an epoch (UTC) gives the sky those element sets give at that epoch (SGP4), not a measurement, and sky_source says which. Carries the advisory: not type-approved navigation equipment. No Monte Carlo over MCP (bulk samples; use the CLI, Python or WASM). Inline only, at most 4 MiB.
iq_signalsThe GNSS IQ layer's set-up, as JSON: signals (the signal names iq_scene, iq_acquire and iq_track accept), enabled (whether the IQ file tools are on), work_dir (the only folder they read and write; every path argument is relative to it), max_samples (the most complex samples one call may generate or process) and, when off, reason. IQ samples never travel through the protocol: tools take file paths in the work directory and reply with compact JSON summaries. The IQ layer adds no interference or spoofer synthesis; nothing is ever transmitted. Call this first.
iq_infoDescribe one IQ recording in the work directory without processing it: kind (raw with sidecar, SigMF, SigMF collection), sample format, sample rate, centre frequency, total samples, duration, data files and their size, capture boundaries and annotation count, as JSON (the same row kshana iq info prints). Optional raw describes a raw file with no sidecar; optional hash adds each data file's SHA-256 (reads the whole file).
iq_sceneGenerate a multi-satellite GNSS IQ scene into a file in the work directory (kshana iq scene). Stated-profile mode: signal + prns (+ optional dopplers_hz, cn0_dbhz, data). Broadcast mode: nav (a RINEX navigation file in the work directory) + rx_pos [lat, lon, alt] places each healthy GPS satellite at its true broadcast geometry. Optional channel applies ionosphere, troposphere, scintillation, multipath, land-mobile shadowing or NLOS at the signal level. rate_hz × duration_s must fit the sample budget (see iq_signals). Writes the recording (raw + <out>.json sidecar, or a SigMF pair) and a truth sidecar; replies with the files written and their byte counts, the sample count and sampling, and the truth's first epoch per satellite (code phase, Doppler, C/N0) to score iq_acquire against. The IQ layer adds no interference or spoofer synthesis; nothing is ever transmitted.
iq_acquireFFT acquisition of one or more PRNs over an IQ recording in the work directory (kshana iq acquire). Reads only the samples one search needs (coherent × noncoherent code periods), which must fit the sample budget. Optional frontend stages (band-pass, notch, blanking, excision, AGC, quantiser) run first. Replies with one detection per PRN: acquired, doppler_hz, code_phase_chips, the normalised peak statistic, its detection threshold and the peak_ratio; json_out / csv_out also keep the full result as files, and surface_out (one PRN; .csv, .json or .bin) keeps the whole Doppler × code-phase correlation-power surface with the peak and its parabolic and fine-search Doppler refinements.
iq_trackAcquire then track one or more PRNs over an IQ recording in the work directory (kshana iq track): acquisition initialises each channel, then the DLL/PLL (optionally FLL-assisted) loop bank replays the recording once. The samples tracked (the whole recording, or its first max_seconds) must fit the sample budget. The loops come from design (a kshana.loop-design/1 TOML file in the work directory, design_name to pick one) or the built-in design, with the loop arguments overriding it; reacquire re-acquires a channel that loses lock or false-locks. Tracking streams, so memory does not grow with the recording. Replies with the design's name and hash, any warnings (commensurate_sampling: a sample rate that is a multiple of half the chip rate makes code-loop jitter and bias unrepresentative) and, per channel, the epoch count, seconds tracked, final Doppler and code phase, final and mean C/N0 (dB-Hz), the fractions of epochs in phase and code lock, locked_at_end, the final lock state, false locks detected and re-acquisitions. Per-epoch output goes to files only: epochs_out (E/P/L, discriminators, loop states, C/N0, lock state; .csv/.jsonl/.bin), events_out, json_out / csv_out. A PRN that is not acquired is refused with its statistic and threshold.
iq_frontendApply receiver front-end and interference-mitigation DSP to an IQ recording in the work directory and write the result as a new raw recording with a <out>.json sidecar (kshana iq frontend). stages picks any of: bandpass_hz [lo, hi] FIR, adaptive notch, pulse blanking, frequency-domain excise, agc, and a bits-bit quantiser (preceded by an automatic AGC unless no_agc), always in that order. The whole input must fit the sample budget. Replies with the samples processed and the files written with their byte counts. This processes a recording; it synthesises nothing.
iq_campaignRun a lab-replay campaign held in the work directory (kshana iq campaign): recordings (each described by a kshana.test-conditions/1 file stating the lab's known truth) x front-end chains x loop designs, each cell tracked and scored against the stated conditions (time to loss of lock, re-acquisition time, C/N0 degradation against the stated J/S beside an analytic reference labelled MODELLED, false-lock rate, PLL/DLL jitter, availability). Incremental: one call runs the pending cells that fit the sample budget (or max_cells), every finished cell is kept, and the next call resumes. Replies with the cell counts, failures, the files written, and the digest once every cell is done. Scores recorded data only; it synthesises no interference.
iq_campaign_statusReport a lab-replay campaign's progress from its output folder in the work directory, reading files only: cells done and pending, the recordings, front ends and designs in the plan, and the digest once every cell is done.
iq_sweepReplay one IQ recording in the work directory across several tracking-loop designs and report each design's steady-state result (kshana iq sweep): the designs are every design of a kshana.loop-design/1 file (design), or the product of the pll_bws_hz, dll_bws_hz, spacings_chips and coherents lists on the built-in design. Each PRN is acquired once and every (design, PRN) channel tracks the same samples, so each result is exactly that of running the design alone. Replies with, per design and PRN, epochs, phase_jitter_deg and code_jitter_chips (over the second half of the run), phase_lock_frac, code_lock_frac, mean_cn0_dbhz and the design's hash; json_out / csv_out keep the table as files. The span tracked must fit the sample budget (max_seconds narrows it) and at most 256 (design, PRN) channels run per call. This processes a recording; it synthesises nothing.
iq_monitorRun the interference and spoofing detection monitors over an IQ recording in the work directory (kshana iq monitor): the wideband power and spectral monitors, and, given signal + prns, the per-satellite C/N0 and signal-quality monitors, each against a baseline learned from the first baseline_s seconds (or from a settings file). Replies with the series (name and length), every event the monitors raised (start, end, monitor, what changed; at most 200 in the reply), and the settings and baselines the monitors learned; json_out keeps the whole report (every series, event and spectrum) and csv_prefix writes <prefix>.series.csv and <prefix>.events.csv. The span must fit the sample budget (max_seconds narrows it). A monitor event says a measured quantity left its learned baseline; it does not identify a cause or a source. This scores recorded data only; it synthesises nothing. Evidence tier: MODELLED.
iq_test_conditionsValidate a lab test-condition file (kshana iq conditions): a kshana.test-conditions/1 file, TOML or JSON text, stating the lab's known truth for a recording (the satellites expected, the settle time, the stated jamming or interference schedule). Replies with the resolved conditions and their hash, or the reason the file is invalid. Inline only: nothing is read from disk, and a recording path the file names is not opened (a campaign resolves those inside the work directory). Input is capped at 4 MiB.
iq_labfitFit the tracking-loop loss-of-lock model to lab runs (kshana iq labfit): an iq-labfit scenario TOML names one or more runs, each a receiver log plus its stated test conditions; the engine loads each log, fits the loop and empirical models, bootstraps the uncertainty and computes the hold-out error. Everything is inline: each run's log gives text or base64 (a path is refused) and the tool reads and writes no file, so it does not need the IQ work directory. Alternatively the scenario's [input] names campaign = "<out-dir>", a finished kshana iq campaign output folder: the tool then fits the C/N0 and lock models to its scored cells (a kshana.labfit-iq/1 report; Q is stated, never fitted, and the identifiable J/S offset is fitted; with mode = "validation" a [validation] table is required). That folder is resolved relative to the IQ work directory and must lie inside it (anything outside is refused); it is read, nothing is written. Replies with the parsed report, the residuals and predictions as CSV text and a Markdown summary. Input is capped at 4 MiB. The fit describes the lab runs given; it is not a prediction for other receivers or conditions beyond what the report states. Evidence tier: MODELLED.
assess_vessel_streamScore a bounded excerpt of a vessel's NMEA 0183 stream the way kshana receiver-trust live scores it, and return per-epoch trust state (calibrating, nominal, degraded, untrusted) and 0-100 score with the monitors that deducted (live JSON-lines schema 1.3: each epoch carries position, an advisory statement that the output is advisory, and its satellite geometry (good, degraded with reasons such as few-satellites or high-pdop, or unknown when the excerpt has no GSV or GSA) with a label (good, fair, poor; geometry deducts only when poor); every deduction carries a class: geometry (the sky, not a finding that no attack occurred), environment or inconsistency (attack-like)), the summary (counts by state, geometry and class, lowest and final score, when the first untrusted epoch came) and the last $PKSHT sentence. session_toml declares the vessel ([platform] kind = "vessel", its speed, acceleration and turn-rate limits, antenna height, whether a heading sensor is on the bus). The excerpt must hold the calibration window; input is capped at 2 MiB and 20,000 epochs, and the reply carries at most 200 degraded or untrusted epoch lines. This is the bounded form of the live command: no socket is opened and nothing is written to a port, and the gate and the telemetry exporters (the long-running process and its --listen server) are command-line only. The checks cannot see a spoofer whose fix is consistent with everything on the bus. Advisory only: not type-approved navigation equipment; the operator remains responsible. Evidence tier: MODELLED.
jammertest_importRead the published Jammertest test catalogue and transmission plan (NPRA/jammertest-plan, MIT) as scheduled truth (kshana jammertest import): the slots of one test area become receiver-trust events with the catalogue id and year in each label. plans holds one plan file per day, log_start_utc is the log's first epoch, local_offset_h the plan's offset from UTC (default 2, CEST). Returns events_toml (append it to a receiver-trust session), events (test id, kind, onset and end in seconds since the log start), and the counts skipped. The events are PLANNED slots, not recorded on-air times: a slot may start late or never run, and the plan's status field is mostly empty. No contact or personal field of the plan is read. Input is capped at 4 MiB per text. Evidence tier: MODELLED.
jammertest_scoreScore a receiver log against the Jammertest schedule (kshana jammertest score): per scheduled test the detection latency (first alarm minus planned start), whether it was detected within the tolerance, late or missed, and the time to recover (an alarm-free stretch of recover_hold_s), plus the false alarms outside every slot and its guard. session_toml needs only [log] format = "ubx" (or rinex, android, nmea, sbf); give the log as log (text formats) or log_base64 (binary). Needs the catalogue and plan JSON (catalog_json, plans) and the test area (location). Returns the scorecard: tests, summary, baseline_contaminated and a MODELLED label. The schedule is planned slots, not recorded on-air times, so a miss may be a test that never ran. A signed evidence pack needs a signing key: use the command line (kshana jammertest score --key). Input is capped at 4 MiB per text. Advisory only: not type-approved navigation equipment; the operator remains responsible. Evidence tier: MODELLED.
referee_location_scoreScore where a monitoring network said interference came from (kshana jammertest locate-score, 0.41 row B2): per report the event it belongs to (by id, or by time window and nearest truth), the horizontal geodesic error and vertical error, and for each region (an ellipse with its covariance, a polygon or grid cells) whether it contains the truth and its area; per event and pooled the median and 90th-percentile error, coverage per level with its binomial check, median region size, time to first location and time to locate within 100 m, 500 m, 1 km and 5 km; and false locations per hour of clean time. Definitions: docs/design/evidence/b2-referee-metrics/PREREGISTRATION.md. Input is capped at 4 MiB per text. It checks arithmetic, not any locator's accuracy. Evidence tier: the metrics are checked against an independent oracle; a locator scored with them is only as good as its own evidence.
assess_vessel_logAssess a vessel's NMEA 0183 log as a batch run (kshana receiver-trust with [platform] kind = "vessel"): the score model, the monitors that ran and every epoch's 0-100 score with its deductions, its satellite geometry (good, degraded, unknown) with a label (good, fair, poor) on every epoch, geometry deducting only when poor, and a class on every deduction (geometry, environment, inconsistency), with geometry_model (thresholds, the cap and floor in force, and provenance) and geometry_summary. session_toml states the vessel's limits and any monitor or score settings (no [log] table needed) and nmea is the log text, which avoids pasting it inside a TOML string. Input is capped at 4 MiB; the reply carries the document with epochs cut to counts by state and at most 200 degraded or untrusted epochs. For a log in another format, or with [[events]] to score, use assess_receiver_log. Advisory only: not type-approved navigation equipment; the operator remains responsible. Evidence tier: MODELLED.
generate_training_nmeaGenerate synthetic bridge NMEA 0183 for crew training from a nmea-scenario TOML (kshana nmea-scenario): a vessel track and a timeline of scripted events (jamming, position drag-off, time spoof, replay delay, with recovery). Returns the checksum-valid sentence set (GGA, RMC, VTG, GSV, GSA, GNS, ZDA, HDT, VBW; the first 2000 lines) and the instructor log (what was injected when, with the true track and a top-level summary of peak speeds and accelerations; drag-off events carry their peak drag speed and acceleration; schema kshana-nmea-training/1) as JSON and text. The receiver's visible-satellite ceiling is receiver.max_used (default 12). Deterministic per seed. TEXT ONLY: nothing here synthesises RF, IQ or any waveform, nothing is transmitted, and the output is for training and testing, never for a vessel's live navigation systems (a marker sentence in the stream says so). Advisory, not type-approved navigation equipment. Streaming to a TCP or UDP address is command-line only. Four example scenarios ship in scenarios/training/.
create_evidence_packCreate a signed evidence pack for a window of a vessel's NMEA 0183 log (kshana receiver-trust evidence): the raw log bytes for the window, the configuration with every threshold, the per-epoch results and reasons, a self-contained summary page, and a manifest listing every file's SHA-256 with the full log's hash and a hash chain, signed with Ed25519. from_s/to_s are seconds since the log's first epoch. Returns the files as JSON (feed them to verify_evidence_pack), the signer's public key and fingerprint. The signing seed is never returned or logged; if signing_key_seed_hex is omitted a one-time key is used and discarded, so the pack proves integrity against the key it names itself, not who signed it: for a key that matters, create the pack on the command line (a seed passed here travels through the conversation). Input is capped at 4 MiB and the reply at 4 MiB (narrow the window). A pack is a technical record of what the engine computed from a log under stated settings; it is not a legal opinion, a finding of fact about any event, or a certification. Evidence tier: MODELLED.
create_round_trip_packCreate the signed laboratory round-trip pack (kshana evidence round-trip, docs/spec/TEST-CONDITIONS.md): links by hash the scenario that produced the motion, the laboratory's kshana.test-conditions/1 document, the receiver log and its score against the stated events, in a signed evidence pack whose config.json carries a round_trip block. Refuses a pack whose conditions and scoring events disagree, or whose stated log SHA-256 is not the log's. NO SIGNAL: nothing is written, replayed or scheduled; how a scenario's motion reached the receiver is the operator's responsibility and is recorded only as stated. The signing seed is never returned or logged; omitted, a one-time key is used and discarded (integrity, not identity). Input is capped at 4 MiB and the reply at 4 MiB. A technical record, not a legal opinion or a certification. Evidence tier: MODELLED.
verify_evidence_packVerify a signed evidence pack (kshana evidence verify): every file's SHA-256 against the manifest, the hash chain, the Ed25519 signature, and with public_key (the signer's key, from the signer by another route) that the signer is the one expected, and with full_log that the log you hold is the one the pack records and that the slice came from it. Returns the report: ok, each failure by code and file, every check, signer_pinned, notes, and a verdict: verified (signer pinned), intact-signer-not-pinned (everything checks but no trusted public_key was given, so the signature proves only that the pack is intact against the key it names itself, which anyone can generate; say so, do not call it verified) or failed, with a message to show the user. require_timestamp fails a pack that carries no timestamp token. Inputs are capped at 4 MiB. A verified pass says the record is unchanged and who signed it (the key you supplied); it does not say what caused any event, who is responsible, or that the log shows what the receiver really received.
build_interference_mapBuild a GNSS interference map from openly licensed aircraft (ADS-B NIC/NACp) or ship (AIS) position reports given as CSV text (kshana interference-map adsb|ais). Returns one GeoJSON document per UTC day (schema kshana-interference-map/v1) (file names <source>-<dataset>-<date>.geojson; method version 2) in which each published grid cell is degraded, not_degraded, insufficient_sample, withheld_day_confounded or withheld_no_background (ADS-B) or anomalous/not_anomalous (AIS), with the method, its pre-registered thresholds, the dataset licence and attribution embedded. Every per-cell count below the publication minimum (5) is null (withheld, never zero), and a day whose background cannot be estimated withholds its calls. Aggregate only: identifiers are hashed in memory and never returned, and a cell with fewer than 5 distinct aircraft or vessels is not published. dataset is an approved preset or custom (with licence, licence_url, attribution). Input is capped at 4 MiB and the reply at 4 MiB (use a coarser cell_deg or the command line for more). Nothing is fetched: land polygons, if wanted for AIS, are passed in. A degraded cell does not identify interference as the cause; an unpublished cell is not evidence of a clear cell; this is not a forecast. Evidence tier: MODELLED.
interference_emitter_regionsEstimate emitter regions from openly licensed aircraft (ADS-B) or ship (AIS) reports given as CSV text (kshana interference-map locate): where, under stated assumptions, a source of the degraded reports could be, as regions at stated confidence levels with a centroid and an uncertainty ellipse, never a bare point. Returns {stem, geojson, summary, csv, svg, sessions_published, sessions_withheld}, each text labelled with its evidence tier. Aggregate only: a region is not the position of anyone and not a finding of the cause. Input is capped at 4 MiB. Nothing is fetched. Evidence tier: MODELLED.
connect_mapMap any receiver, timing or monitoring log to Kshana observations with a kshana.connect/1 mapping file, no code (kshana connect map, docs/CONNECT.md). Takes the mapping and the station as TOML text and the log as text (CSV or JSON, at most 4 MiB) and returns the kshana.obs/1 records as JSON lines, byte-identical to the command line. A row that cannot be read is an error naming the line and field. Nothing is read from or written to disk.
route_exposureSummarise how much of a route runs through degraded cells of one or more interference maps (kshana route-exposure): for each map (one per source per UTC day, the GeoJSON build_interference_map returns), the route length and the shares of its length in degraded cells, in cells that were not degraded, in cells with too little sample to assess, and in cells not observed. The route is a GeoJSON LineString or lat,lon CSV text; date_from/date_to (YYYY-MM-DD) keep maps in a date range. Input is capped at 4 MiB per item. Cells not observed are not evidence of a clear route; a degraded cell does not identify interference as the cause; this describes past reports and is not a forecast. Evidence tier: MODELLED.
compliance_reportFill the public-framework mapping from Kshana result documents (kshana compliance-report): which rows of six resilience frameworks and standards (the US DHS Resilient PNT framework v2.0, IMO guidance for ships, EASA guidance for aviation, NIS2 Article 21, EN 16803, NIST IR 8323r1) the runs given support evidence for, which they do not, and the gap each row keeps. Pass each run as label, result (the result JSON text) and, when you have it, scenario (the scenario TOML, which names the kind a result does not; a receiver-trust result needs none). At most 64 runs and 4 MiB in all; nothing is read from disk. Each row's status is evidenced, partly-evidenced, not-evidenced or out-of-scope, and every row keeps its gap even when evidenced; inputs that could not be used are listed in unrecognised and count for nothing. Show the report's statement with any result, verbatim: a status means a run supports evidence for the capabilities the row names; it is not a finding that a framework is met, and it does not mean any product has been rated or approved by anyone. Do not describe the output in any stronger terms. Evidence tier: MODELLED.
compliance_mappingThe static public-framework mapping (kshana compliance-report --mapping / --sources) as Markdown: one table per framework with each row's paraphrased ask, the Kshana outputs that support evidence for it and the gap the outputs do not close; or, with sources true, the source documents the tables cite with versions and URLs. Led by the statement every report carries, which stays with any excerpt: a row marked evidenced means a run supports evidence for the capabilities the row names; it is not a finding that a framework is met, and it does not mean any product has been rated or approved by anyone. Needs no runs.
fit_imu_logFit the sensor parameters of the hybrid and fusion scenarios from a stationary IMU log (kshana imu-fit, docs/MACHINE-INPUTS.md). Those scenarios take noise parameters, not a time series: this reads them off a log recorded with the sensor held still, by the overlapping Allan deviation of the integrated signal. Returns JSON: fit (accelerometer bias, velocity-random-walk PSD q_va, gyro bias, angle-random-walk PSD q_arw, bias-instability floor when the log is long enough to show one, the log's rate and span, the early Allan slopes, and notes on what could not be fitted or trusted), toml (an [accel_classical] table whose provenance names the log's SHA-256, ready to paste into a scenario) and sha256. A log that was not stationary, or is too short or unevenly sampled, gives wrong parameters or is refused; the slopes (about -0.5 where white noise dominates) show which. Nothing is written to disk. Evidence tier: MODELLED (the estimator applied to the log, no external oracle).
ephem_exportWrite a JPL Horizons vector table (for example the CAPSTONE or Artemis I states of the mission thread) as a file flight-dynamics tools load (kshana ephem-export, docs/FLIGHT-DYNAMICS-EXPORT.md): a CCSDS OEM 2.0 of every state (format oem), a CCSDS OPM 3.0 of one state (opm, index), or a NAIF SPK kernel of type 13 or 9 (spk). The values are copied, not computed: the OEM and OPM write each double in shortest round-trip form and the SPK stores the same doubles, with the table's own epochs (TDB), object, centre and frame (ICRF, frame code 1 in the SPK). Returns JSON: the table's object, centre, NAIF ids, frame, time scale, number of states and span; the file (suffix, bytes, sha256, encoding utf-8 or base64 for the SPK, content); and read_back, the engine reading the file back and comparing every state with the one written (identical of states, the largest differences, and for the SPK the interpolated state at each node). Nothing is written to disk.
list_standards_packsList the standards packs (kshana standards-pack list): scored scenario sets for the DHS Resilient PNT framework test profiles, IMO MSC.1/Circ.1575 and ICAO Doc 9849 Appendix F, each with the bars it states before the run and the compliance rows it supports evidence for. Needs no input. A pack measures modelled scenarios against stated bars; it rates no product. Evidence tier: MODELLED.
run_standards_packRun one standards pack (kshana standards-pack run <id>): every scenario in it, scored against bars stated before the run. Returns the report (each test MET, NOT MET, or NEEDS INPUT when it needs a receiver log and is not scored; each bar with its measured and expected value) and the same as markdown. Pass the report JSON to compliance_report to see the rows the pack supports evidence for. Say plainly that a MET bar means a modelled scenario met a stated bar, and that a NOT MET is a result on record; never describe the output as showing that a product or a framework is met. Advisory only: analysis output, not type-approved navigation equipment. Evidence tier: MODELLED.
lunanet_afs_checkCheck the LunaNet Augmented Forward Signal (AFS) against the published specification, pinned to LNIS Version 5 Applicable Document 1 Volume A (LSIS-AFS V1.0, 29 January 2025) (kshana lunanet-afs-check, docs/LUNANET-AFS.md). Mode spec checks this implementation against the document's printed code tables (the first and last 24 chips of every AFS-I Gold, AFS-Q Weil and tertiary code for PRN 1 to 210, and both Legendre sequences) and worked examples (SB1 BCH, CRC-24Q), bars B1 to B10 of a pre-registration; B4 reports one miss (the document prints the same last 24 chips for tertiary PRN 147 and 151). Mode symbols checks a hard-decision symbol stream (text of 0 and 1) for the synchronisation pattern, SB1 decoding, FID, TOI continuity and frame spacing. Subframes 2 to 4 (rate-1/2 LDPC, CRC-24Q) are NOT verified: the LDPC matrices are in a separate annex that is not implemented. Mode generate returns a test stream with placeholder subframes: symbols, not a waveform; Kshana writes no signal. VALIDATED only against the printed tables of that edition, which the document itself marks TBC; say so, and do not describe a result as showing that any LunaNet node or service is correct. Advisory only.
score_benchmarkScore a kshana-bench submission (kshana bench score, bench/SPEC.md, docs/BENCH.md): a predictions file (kshana-bench-predictions/1) against a truth file (kshana-bench-truth/1), both JSON text, at most 4 MiB each, and return the result file (kshana-bench-result/1) with the spec version, task (a detection on receiver logs, b detection on IQ, c timing holdover prediction, d out-of-distribution optimism gap), split, the SHA-256 of both inputs and the task's metrics (AUC, detection probability at a false-alarm cap, RMSE per horizon, or the optimism gap). threshold is the declared alarm threshold of tasks a and b. Nothing is read from disk or written. Every score is MODELLED and describes a log or corpus, never a product; it is not a certification and no organisation is endorsed by a score. Evidence tier: MODELLED.
render_leaderboardRender kshana-bench result files (kshana bench leaderboard) as the static leaderboard page, HTML text in the reply: results is a list of kshana-bench-result/1 JSON texts (at most 256, 4 MiB each), each validated first; a file scored under another major spec version is refused because results of different major versions are never put in one table. A row says this file scored this number on this split; it does not mean any product has been rated or approved by anyone. Nothing is written. Evidence tier: MODELLED.
trust_telemetryRender a GNSS trust stream or a receiver-trust result as security telemetry text (kshana trust-telemetry, docs/TRUST-TELEMETRY.md), with the same encoders the command line uses: prometheus (the exposition of the final state), cef or leef (one RFC 5424 syslog line per band change, or per epoch with syslog_all; no timestamp, because no clock is read) or otlp (the OTLP/HTTP JSON metrics payload). input_kind is jsonl (default) or result; a stream line that does not parse is skipped and counted in kshana_trust_input_errors_total. Nothing is sent, served or written: the output is text in the reply (the running exporters, which are a process, stay on the command line). The receiver-reported position is left out unless expose_position is true. An input that carries satellite geometry (live schema 1.3, results from 0.36) adds the geometry label (good, fair, poor; never scored but for poor) and status, HDOP, PDOP, VDOP and satellites used, and a class label (geometry, environment, inconsistency) on each reason; an older input renders exactly as before. Advisory only: Kshana is not type-approved navigation equipment (IEC 61108, IEC 61162) and the operator remains responsible. Evidence tier: MODELLED.
export_test_benchExport a scenario's vehicle motion and events for a laboratory GNSS simulator (kshana bench-export, docs/TEST-BENCH.md): a motion CSV and its JSON description (Earth-fixed and geodetic position, velocity, attitude, UTC), NMEA 0183 GGA/RMC sentences, a waypoint text when the sample grid is millisecond-regular, and the scenario's events as CSV and as [[events]] TOML for a receiver-trust scenario. Applies to gnss-ins (its navigation-state outages are the events), jamming and gnss-sim; another kind is refused with the reason. epoch is the UTC instant of motion time zero, YYYY-MM-DDTHH:MM:SS (default 2024-01-01T00:00:00Z). Nothing is written to disk: the first content item is a JSON index (files with suffix, bytes, sha256; notes on any file left out; notice), followed by each file's text in index order. The same scenario and epoch give byte-identical files. NO SIGNAL: nothing exported is, models or drives a radio-frequency or baseband signal, and an event is a labelled interval, not a recipe for producing interference; the simulator and its operator supply the signals and are responsible for running them only where authorised. Keep the notice with the files. Kshana publishes no results from such runs. Evidence tier: MODELLED.
attach_evidence_timestampBind an RFC 3161 timestamp token to an evidence pack (kshana evidence attach-timestamp), in memory: files is a pack as create_evidence_pack returns it, token_base64 the bytes of the .tsr file from a timestamp authority. The token is stored as timestamp.tsr beside the signed manifest, not inside it, and the pack with the token must still verify or nothing is attached; an existing token is kept unless replace is true. Returns the updated files (feed them to verify_evidence_pack with require_timestamp true to insist the token is present) and the verification notes. This does NOT check the timestamp authority's signature on the token or the authority's certificate (it checks the token's structure and that its message imprint is the hash of this pack's manifest.json): say so, and point the user to openssl ts -verify. Input and reply are capped at 4 MiB. A timestamp shows a hash existed at a time the authority states; it is not a legal opinion. Evidence tier: MODELLED.
One table, generated from the repository's packaging/channels.json and cross-checked against its READMEs, so each command is the one the README shows, pinned to v0.41.0. Prebuilt binaries for every operating system, the desktop assistant extension, one-click buttons for Cursor and VS Code, npx and uvx launchers, Homebrew, Scoop and winget, the registries, and a self-hosted HTTP mode. Channels marked when published go live with the release.
The engine on its own, in the language or place you work.
For anyone, nothing to install. Needs: none.
The engine runs locally as WebAssembly; nothing is uploaded.
For engineers who want the kshana command. Needs: Rust.
Pinned to v0.41.0cargo install kshana --version 0.41.0
Then check itkshana --version
For Rust developers embedding the engine. Needs: Rust.
Pinned to v0.41.0cargo add kshana@0.41.0
Then check itcargo tree --depth 1 | grep kshana
For analysts and notebooks. Needs: Python.
Pinned to v0.41.0pip install kshana==0.41.0
Then check itpython -c "import kshana; print(kshana.version())"
For web and Node.js developers. Needs: Node.
Pinned to v0.41.0npm install kshana@0.41.0
Then check itnpm ls kshana
Advisory, not type-approved navigation equipment: the operator remains responsible for navigation. The server runs on your computer; nothing is sent to Ashforde OÜ.
For anyone using an MCP-capable assistant. Needs: Rust 1.88+.
Pinned to v0.41.0cargo install kshana-mcp --version 0.41.0
Then check itcargo install --list | grep kshana-mcp
For no Rust toolchain; the MCP server in a container. Needs: Docker.
Pinned to v0.41.0docker run --rm -i ghcr.io/ashfordeou/kshana-mcp:0.41.0
Then check itdocker image inspect ghcr.io/ashfordeou/kshana-mcp:0.41.0 --format '{{.Id}}'
For desktop assistant users, no terminal. Needs: none.
macOS (Apple silicon)macOS (Intel)WindowsLinux (x86-64)Linux (Arm)
Double-click kshana-mcp-<target>.mcpb.
For Cursor users. Needs: Node, or Docker.
Pinned to v0.41.0kshana-mcp@0.41.0 / ghcr.io/ashfordeou/kshana-mcp:0.41.0
For VS Code and Insiders users. Needs: Node, or Docker.
Pinned to v0.41.0kshana-mcp@0.41.0 / ghcr.io/ashfordeou/kshana-mcp:0.41.0
Install in VS Code (npx)Install in VS Code (Docker)Install in VS Code Insiders (npx)
For Node users, any MCP client. Needs: Node 18+.
Pinned to v0.41.0kshana-mcp@0.41.0
Then check itnpx -y kshana-mcp@0.41.0 --version
A launcher: it downloads the release binary, verifies SHA256SUMS and runs it.
For Python users, any MCP client. Needs: Python 3.9+ with uv or pipx.
Pinned to v0.41.0kshana-mcp==0.41.0
Then check ituvx kshana-mcp==0.41.0 --version
For macOS and Linux. Needs: brew.
Pinned to v0.41.0formula for v0.41.0
Then check itkshana-mcp --version
For Windows. Needs: Scoop.
Pinned to v0.41.0manifest for v0.41.0
Then check itkshana-mcp --version
For Windows. Needs: winget.
Pinned to v0.41.0winget install AshfordeOU.KshanaMcp --version 0.41.0
Then check itkshana-mcp --version
Appears once Microsoft merges the submission.
For no package manager. Needs: none.
Download kshana-mcp-<target> from the release and check it against SHA256SUMS.
For registry-aware MCP clients. Needs: a registry-aware client.
Search io.github.ashfordeOU/kshana-mcp.
For clients that take a URL. Needs: your own host.
Pinned to v0.41.0v0.41.0
Loopback by default; a non-loopback bind needs --allow-remote and a bearer token. Kshana hosts no endpoint.
Plugins and images that carry Kshana into other tools.
For IntelliJ, PyCharm and CLion users. Needs: a JetBrains IDE.
Settings → Plugins → Marketplace → search "Kshana" (plugin ID dev.kshana.ide). Right-click a scenario .toml and choose Run Kshana Scenario.
For boat owners running a Signal K server. Needs: Node, a Signal K server.
Pinned to v0.41.0npm install signalk-kshana-trust@0.41.0
Then check itnpm ls signalk-kshana-trust
For OpenCPN chartplotter users. Needs: OpenCPN 5.8+.
Download the plugin tarball from the release. The release carries the tarball and its catalogue metadata XML; listing in OpenCPN's catalogue is a pull request opened by hand.
For operators running Grafana. Needs: Grafana.
Import kshana-grafana-*.json from the release.
For gate and bench deployments. Needs: Docker.
Pinned to v0.41.0docker pull ghcr.io/ashfordeou/kshana-reference-build:0.41.0
From a browser tab to a continuous integration (CI) regression suite. Every door runs the same engine and writes the same JSON result, SVG (Scalable Vector Graphics) chart and HTML (HyperText Markup Language) report. Pick one; every command is real and copies with one click.
Any bundled scenario, run on your machine as WebAssembly; nothing installed, nothing uploaded. Tune it, compare runs, sweep a parameter and export a reproducible report.
Only Kshana Studio, for a course page or a report, with the scenario and view preselected
studio/index.html?embed=1&scenario=integrity-raim&tab=timeserieskshana <scenario>.toml writes result.json, chart.svg and report.html
Output is deterministic from scenario, seed and engine version, so a committed result.json is a regression test (CI: continuous integration): rerun and diff it
kshana --study: a suite of scenarios into one stamped study.json and study.html, free. Not the paid custom study.
kshana::api::run_toml returns JSON, SVG, a summary and CSV (comma-separated values)
kshana.run and run_full, plus validate_toml and list_kinds
run, summary and chart_svg in the browser or Node.js
53 tools an AI assistant can call, each a thin wrapper over the public API
The MCP server without a Rust toolchain, multi-architecture
Right-click a scenario .toml, Run Kshana Scenario, read the figures in a tool window
The command line, the Rust, Python and JavaScript bindings and the file formats the engine reads and writes, side by side. Everything here is the free open core.
kshana --helpFrom the binarykshana <scenario.toml> [--study-name <s>] [--eop <finals2000A>] [--export-sp3 <out.sp3>] [--export-omm <out.omm>] [--export-oem <out.oem>] [--export <czml|kml|geojson|stk|sigmf|all|list>]... [--import-route <route.geojson>]
kshana <scenario.toml> --animate <svg|html|frames|all> [--animate-fps <n>] [--animate-duration <s>]
kshana --study <suite.toml>
kshana --validate <scenario.toml>
kshana receiver-trust <scenario.toml>
kshana receiver-trust live <session.toml> [--stdin | --file <path> [--follow] | --tcp <host:port> | --udp <port>] [--gate] (kshana receiver-trust live --help)
kshana receiver-trust evidence <scenario.toml> --from <t0> --to <t1> --key <keyfile> --out <dir> (kshana evidence --help)
kshana evidence <keygen|verify|attach-timestamp> ... (kshana evidence --help)
kshana jammertest <import|score> ... (kshana jammertest --help)
kshana evidence round-trip <scenario.toml> --scenario <bench-scenario> --conditions <file> --from <t0> --to <t1> --key <keyfile> --out <dir> (kshana evidence --help)
kshana trust-telemetry [options] (kshana trust-telemetry --help)
kshana imu-fit <imu.csv> [--format csv|euroc] [--axis x|y|z] [--expected-mean <m/s2>] [--id <name>] [--json]
kshana ephem-export <horizons.txt> [--format oem|opm|spk] [--out <file>] [--index <n>] [--spk-type 13|9] [--degree <n>] [--creation-date <YYYY-MM-DDTHH:MM:SS>] [--object-id <id>]
kshana nmea-scenario <scenario.toml> [--out <file.nmea>] [--tcp <addr>|--udp <addr>] (kshana nmea-scenario --help)
kshana interference-map <adsb|ais|fetch-land> ... (kshana interference-map --help)
kshana route-exposure --route <route> --map <map.geojson|dir> [--from <date>] [--to <date>]
kshana bench <spec|truth|cases|score|baseline|seal|reveal-check|manifest|verify-manifest|validate|leaderboard> ... (kshana bench --help)
kshana bench-export <scenario.toml> [--out <base>] [--epoch <YYYY-MM-DDTHH:MM:SS>]
kshana compliance-report [--out <base>] <result.json>... | --mapping | --sources
kshana lunanet-afs-check <spec [--json] [--strict]|symbols <file> [--max-sp-errors <n>] [--json]|generate --frames <n> [--toi0 <t>] --out <file>>
kshana standards-pack <list|run <id> [--json] [--out <base>]|rows <id>|tests <id>>
kshana partner check <submission.toml> [--json]
kshana scenario <migrate <scenario.toml> [--in-place] | version>
kshana obs <convert <log> --format <format> --station <station.toml> [--out <file>] | check <file.obs.jsonl> [--json]>
kshana connect <map <input> --mapping <connect.toml> --station <station.toml> [--out <file.obs.jsonl>] | check <vector.toml|dir> [--bless] | watch <dir> --mapping <connect.toml> --station <station.toml> [--suffix <.csv>] [--interval <s>] [--once] | mqtt <host:port> --topic <filter> --mapping <connect.toml> --station <station.toml> [--header <row>] [--qos 0|1] [--user <name> --password-env <VAR>] [--client-id <id>] [--max-messages <n>] [--per-topic] | nats <host:port> --subject <s> --mapping <connect.toml> --station <station.toml> [--header <row>] [--per-topic] [--user <name> --password-env <VAR> | --token-env <VAR>] [--max-messages <n>] | ws <ws://host:port/path> --mapping <connect.toml> --station <station.toml> [--header <row>] [--max-messages <n>] | check-live <vector.toml|dir> [--json] | load-test [--stations <n>] [--rate <Hz>] [--seconds <s>] [--via memory|mqtt] [--json] | adapters <list|check> [<dir>] [--json]>
kshana osnma verify <pages|vectors.csv|stream.ubx> [--merkle-root <hex>] [--public-key <id:type:hex>] [--reference-time <gst-s>] [--json] (kshana osnma --help)
kshana iq <scene|acquire|track|sweep|labfit|campaign|conditions|frontend|monitor|inventory|info|extract|convert|decimate> ... (kshana iq --help)
kshana sky <request.json|request.toml> | --site <lat,lon[,h]> --systems <a,b,...> [--time <s>] [--mask <deg>] [--skyline-preset <name>] [--uere <m>] [--monte-carlo <n> --seed <s>] [--svg] (kshana sky --help)
kshana skyline --preset <name> [--json] | --presets | --profile <skyline.json|toml>
kshana kinds [--json]
kshana example [<name>]
kshana --help | --versionA run writes result.json, chart.svg, report.html, report.json, table.csv next to the scenario; --export-sp3, --export-omm and --export-oem write orbit files; --animate also writes the run as something that moves (animation.svg, animation.html, frames: an animated SVG, a self-contained HTML player or a folder of numbered frames), with --animate-fps and --animate-duration for the playback rate and length; --export writes the scenario's geometry or its synthesised signal for other tools: CZML (Cesium Language), KML (Keyhole Markup Language), GeoJSON (geographic JSON), an STK (Systems Tool Kit) ephemeris file, SigMF (Signal Metadata Format); --import-route reads a route drawn as a GeoJSON line; --eop injects Earth-orientation parameters from a finals2000A file; --study runs a free suite of scenarios into study.json and study.html; kshana kinds --json lists every kind with its fields; kshana example prints a scenario to start from. Results can travel in the Kshana Interchange Format (KIF) envelope. The MCP server exposes the orbit exports as tools.
kshana --study is the free suite runner. If you want the analysis done for you instead, that is a paid custom study.
result.json, chart.svg, report.html and the same report as report.json, plus a CSV (comma-separated values) table for the kinds that publish one. On request it also writes an animation of the run (--animate) and the scenario in the formats other tools read (--export).Each program runs the bundled clock-holdover scenario (write it with kshana example clock-holdover > clock-holdover.toml) and prints the same one-line summary. The package READMEs carry the full versions.
cargo add kshanause kshana::api;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let toml = std::fs::read_to_string("clock-holdover.toml")?;
let out = api::run_toml(&toml)?; // RunOutput { json, svg, summary, csv }
println!("{}", out.summary); // the one-line result string
std::fs::write("clock-holdover.result.json", &out.json)?;
Ok(())
}kshana::api also has run_scenario, validate_scenario, list_scenario_kinds and the orbit exporters. Rust docs
pip install kshanaimport json, kshana
toml = open("clock-holdover.toml").read()
result = json.loads(kshana.run(toml)) # the full result document
print(result["quantum"]["fom"]["integrity"])
result_json, chart_svg, summary = kshana.run_full(toml)
print(kshana.version(), summary)The package also has validate_toml and list_kinds. Python docs
npm install kshanaimport { readFileSync } from "node:fs";
import { createRequire } from "node:module";
import { initSync, run, summary, version } from "kshana";
const wasm = createRequire(import.meta.url).resolve("kshana/kshana_bg.wasm");
initSync({ module: readFileSync(wasm) }); // in a browser: await init()
const toml = readFileSync("clock-holdover.toml", "utf8");
const result = JSON.parse(run(toml)); // the full result document
console.log(version(), result.classical.fom.timing_p95_ns);
console.log(summary(toml)); // the one-line result stringThe same package runs in the browser; it is what Kshana Studio uses. npm docs
Formats the engine handles today, from the repository's standards page (Docs: standards). Open a row for how to reach it and what it was checked against.
--export-oem, MCP export_oem--export-omm, MCP export_omm--export-sp3, MCP export_sp3space-packet scenariospvtorbit scenarios--eop with a finals2000A fileexport_table_csvThe "Kshana — PNT simulator" plugin: right-click any scenario .toml, choose Run Kshana Scenario, and read the figures of merit in a tool window.
kshana bench score turns a submission file and a split's truth into a result file, and kshana bench leaderboard renders result files into a static page. Nothing runs on your behalf and nothing is uploaded.