SPB Git

Repository Public

README.md 43.7 KB

ORIX Sheet icon

ORIX Sheet

Beyond Spreadsheets.

A native macOS spreadsheet, financial-modelling and data-analysis workstation.
One document, one calculation platform: an Excel-sized grid, a validated formula engine, a columnar data engine,
charts and figures, statistics, local Python and on-device assistance. No account. Nothing leaves your Mac.

macOS native Apple Silicon universal build Swift 6 SwiftUI and AppKit native Swift formula engine DuckDB analytics local Python subprocess on-device AI local first core works offline no account

test suites test count line coverage worksheet functions version minimum macOS release build notarization release status DMG size

workbook open benchmark recalculation benchmark dependency chain benchmark large CSV import benchmark

ORIX Sheet — a budget workbook with charts, conditional formatting and the format inspector

Every badge is generated by Scripts/make-badges.py from files in this repository (test reports, benchmark output, release facts). A value that has not been measured is shown as "not measured"; none is typed by hand.


# Contents

Overview · Philosophy · Preview · Grid · Formula engine · Formatting · Tables · Pivot tables · Transform · Large data · Charts · Figure Studio · Finance · Statistics · Python · Local AI · Formula intelligence · Auditor · Automation · Import & export · Native format · Architecture · Stack · Installation · Build · Testing · Benchmarks · Excel compatibility · Privacy · Accessibility · Localization · Roadmap · Release status · Known limitations · ORIX ecosystem · License


# 1. Overview

ORIX Sheet is a document-based Mac application written in Swift 6. It opens and edits workbooks on the same grid size as Excel (1,048,576 rows × 16,384 columns), calculates them with its own formula engine (473 functions, each backed by reference tests), and adds the tools analysts usually leave the spreadsheet for:

You want to… ORIX Sheet gives you
keep a budget a clean grid, 15 working templates, autosave, undo for everything
build a valuation model validated financial functions, a DCF builder that writes live formulas, scenarios, goal seek, Monte Carlo, a model auditor
analyse millions of rows an embedded DuckDB engine: import, preview, SQL, visual transformations, pivots — and only the result comes back into the sheet
run statistics regression with robust errors, tests, time series, PCA, clustering — validated against SciPy and statsmodels
script it local Python against workbook ranges, in a restricted process that you approve first
understand a formula step-by-step evaluation with real intermediate values, a dependency graph, on-device explanations
publish vector charts, multi-panel figures, paginated PDF

Everything listed in this README exists in the code and is exercised by tests; what is partial or missing is listed under Known limitations.

# 2. ORIX Philosophy

  • Instant utility. A new workbook is one click; nothing to sign in to.
  • Professional precision. A function is only listed as supported once it passes reference tests against an independent implementation.
  • Privacy by design. No account, no analytics, no network in the core. Python and AI run on this Mac.
  • Honest software. No decorative features, no simulated results. Lossy exports are announced before they happen. Measured numbers only.
  • Reproducible work. Transform pipelines, pivots, workflows and scripts are stored in the workbook as data you can re-run.

# 3. Application Preview

Light mode
Light mode — the Personal Budget template: KPI tiles, conditional formatting on overspending, two charts bound to live cells, the format inspector.
Dark mode
Dark mode — the same workbook; charts switch to the dark variant of their theme.
Dashboard
Dashboard — a period selector (data validation) drives XLOOKUP/INDEX formulas, KPI cells and both charts.
Template chooser
Template chooser — thumbnails are rendered from the real template workbooks.

All screenshots are rendered by the application's own views (the app or a feature's preview harness draws its window into a PNG); none is a mock-up. Data shown is synthetic sample data and is labelled as such inside the workbooks.

# 4. Spreadsheet Grid

Spreadsheet grid with a structured table

The grid is a single AppKit view that draws only what is visible with CoreGraphics and CoreText. It never creates a view per cell.

  • 1,048,576 × 16,384 addressable cells per sheet, sparse column-major storage, multiple sheets
  • cell, range, multi-range, row and column selection; keyboard navigation with data-edge jumps; current-region select
  • in-cell editing and formula bar, click-to-insert references with coloured range outlines
  • copy / cut / paste (values, formulas, formats, transposed), fill handle with series detection (numbers, dates, weekdays, months, Item 1 → Item 2), fill down / right
  • insert and delete rows and columns with formula rewriting; move blocks with references following
  • row and column resize, autofit, hide, freeze panes, merge cells
  • notes, hyperlinks, named ranges, find and replace, go to
  • unlimited undo / redo through the system undo manager, including structural edits
  • pinch and ⌘-scroll zoom, light and dark appearance, Increase Contrast support

Measured: a full repaint of a 1440 × 900 window takes about 2–8 ms on the build machine and stays under 2 ms after scrolling to the end of a 200,000-cell sheet (app-hosted test). On dense content at 2560 × 1440 a repaint takes 9–16 ms: there is no dirty-rectangle optimisation yet. Details: docs/architecture/grid-engine.md.

Keyboard shortcuts follow Excel where Mac conventions allow; the differences are listed in docs/compatibility/excel.md.

# 5. Formula Engine

A recursive-descent parser produces a locale-independent syntax tree; a tree-walking evaluator computes it. Nothing is ever evaluated through dynamic code execution.

  • operators with Excel precedence (including -2^2 = 4 and left-associative ^), %, &, comparisons
  • A1, absolute and mixed references, whole rows and columns, cross-sheet references, named ranges, structured table references (Sales[Revenue], [@Qty]), spill references (A1#)
  • dynamic arrays with spilling, #SPILL! on conflicts, broadcasting of scalar functions over arrays
  • LET, LAMBDA (including recursion through defined names) and the lambda helpers MAP, REDUCE, SCAN, BYROW, BYCOL, MAKEARRAY
  • localized entry: =SUM(1,5;2) in French regions and =SUM(1.5,2) elsewhere map to the same stored formula

Calculation. Each formula registers its precedents in a reverse index (a hash for single cells, per-column-block interval trees for ranges). An edit marks only its dependents; evaluation is on demand with cycle detection (#CIRC!), a recursion guard that reorders instead of overflowing the stack, progress reporting and cancellation. Volatile functions and visibility-dependent functions (SUBTOTAL, AGGREGATE) are tracked separately. Large passes run in the background while the grid stays usable. Evaluation is single-threaded.

Functions. 473 are available:

Category Count Category Count
Statistical 144 Dynamic array 22
Math 58 Information 21
Financial 49 Lookup & reference 19
Engineering 46 Logical 13
Text 41 Database 12
Date & time 25 Trigonometry 23

Every essential function named in the product brief is present (XLOOKUP, FILTER, SORT, UNIQUE, SEQUENCE, LET, LAMBDA, SUMIFS, XIRR, LINEST, T.INV, …); a test asserts it. The complete catalogue with signatures, summaries and the validation source of each function is in docs/compatibility/formulas.md.

How correctness is established (see docs/mathematics/reference-tests.md):

Library Reference cases Independent references
Math, statistics, engineering, database 15,378 LibreOffice headless recalculation, SciPy + mpmath (40 digits), Python decimal, NumPy, statsmodels
Lookup, dynamic arrays, financial 86,965 68,075 values computed by Microsoft Excel (public ExcelFinancialFunctions data set, Apache-2.0), LibreOffice, independent Python
Text, date and time 7,951 LibreOffice, Python datetime/dateutil, Microsoft documentation examples
Number formats 5,085 LibreOffice TEXT() renderings
Templates, end to end 18,714 cells every formula cell of the 15 templates recalculated by LibreOffice from the exported XLSX: 0 mismatches at 1e-6

Microsoft Excel itself was never driven; where LibreOffice and Excel's documented behaviour differ, the documentation is followed and the deviation is recorded per function.

# 6. Formatting

  • fonts, size, bold, italic, underline, strikethrough, text and fill colours, borders (13 line styles), horizontal and vertical alignment, wrap, indent, merge
  • the full Excel number-format grammar: sections, conditions, colours, digit placeholders, thousands scaling, percent, scientific, fractions, dates and times, elapsed time, text sections, accounting; decimal-correct rounding
  • conditional formatting: value comparisons, formulas, 2- and 3-colour scales, data bars, 19 icon sets, duplicates, top/bottom, above/below average, text, blanks, errors — with a rule manager and live preview
  • whole-row and whole-column formatting without materializing cells; paste formatting; clear formatting

Conditional formatting rule editor

Not rendered in the grid yet: text rotation, shrink-to-fit, rich text inside a cell (see limitations).

# 7. Tables

Convert a range to a named table with header detection, a totals row (SUBTOTAL), banding and structured references. Filter per column (value list with search, conditions, top N), sort on several keys, remove duplicates, find missing values, see inferred column types and quick statistics. Data validation supports numbers, dates, text length, lists (with an in-cell drop-down) and custom formulas, with input and error messages.

# 8. Pivot Tables

Pivot table builder

Pivots are computed by the columnar engine with a single GROUPING SETS query, from a worksheet range or a dataset. Rows, columns, values and filters; sum, count, average, min, max, standard deviation, variance, median, distinct count, product; show-as percentages, running totals and differences; date and numeric grouping; sorting and top N; calculated fields; subtotals and grand totals. The result is written as real, formatted cells in one undoable step; Refresh recomputes; Show Details drills down to the underlying records in a new sheet. Results are verified against pandas.pivot_table.

# 9. Data Transformation

ORIX Transform: applied steps with live preview

ORIX Transform is a visual, reproducible data-preparation pipeline. Each step — filter, sort, rename, change type, split, merge, join, group by, pivot, unpivot, remove duplicates, fill or drop missing values, replace, parse dates, extract text, calculated column and more (23 step kinds) — is stored as data, validated against the schema at that point (the failing step is identified, later ones are marked blocked) and compiled into one SQL statement you can inspect. Preview at any step, refresh from the source, save the result as a dataset, insert it into the sheet or export it.

# 10. Large Data Engine

Data Studio: a one-million-row dataset with column profile

The worksheet grid and the analytical engine are separate execution environments. A ten-million-row file is imported into an embedded DuckDB 2.0.1 engine, previewed through a virtualized window, queried and aggregated there, and only selected results are materialized into worksheet ranges. Materializing more than a sheet can hold is refused with an explanation rather than truncated.

  • sources: CSV, TSV, Parquet, JSON, JSONL, SQLite files, DuckDB files, worksheet ranges; lazy views for Parquet/CSV/JSON
  • virtualized dataset grid, server-side sort and filter, column profiles, SQL console with history
  • export to CSV, Parquet, JSON
  • the embedded engine cannot reach the network or files outside a private staging folder: extension download is disabled, external access is off, configuration is locked (tested, including escape attempts)

Measured on the build machine (M5 Max, release build, 10,000,000 rows × 8 columns, 560 MB CSV):

Step Median
Import CSV into a table 0.30 s
Filtered aggregation 14 ms
Pivot, region × category by year 38 ms
Join with 100,000 customers + group 88 ms
Preview window at row 5,000,000 5 ms
Parquet filter with push-down 4 ms

Source: Packages/SheetData/BENCHMARKS.md. These are measurements on one machine, not guarantees.

# 11. Charting

Charts in the sheet
Charts live in the sheet, follow their cells and redraw from a cache (about 1 µs per chart on a cache hit).
Interactive chart viewer
Interactive viewer: hover inspection, zoom and pan, linked selection, a what-if slider that drives a cell.
Chart picker
The picker proposes charts for the selection first; thumbnails are drawn from the selected data.
Chart inspector
Inspector: data, style, axes and elements (trendlines, error bars, annotations).

21 chart kinds, all drawn from data by one vector engine: line, bar, column, area, scatter, bubble, histogram, box plot, violin, heatmap, waterfall, candlestick, pie, donut, radar, treemap, 3D surface (static projection), contour, density, time series and combination charts with a secondary axis. Stacking, logarithmic and date axes, six trendline types with equation and R², error bars, confidence bands, reference lines and bands, data labels, ten themes including colour-blind-safe palettes. Blank, text and error cells are never plotted as zero.

Export is vector wherever the format allows: PDF and SVG (real text, no rasterization), PNG at 1×/2×/3×. Statistical conventions (binning rules, quartile methods, KDE bandwidths, decimation) are documented and tested against NumPy, SciPy and matplotlib.

# 12. Figure Studio

ORIX Figure Studio: a four-panel figure

Compose multi-panel figures from the workbook's charts: grid layout with spans, panel labels, shared axes, one typography ladder for all panels, themes, true-size preview, and export presets (vector PDF and SVG, PNG at 300 or 600 dpi). Templates for papers, reports, presentations and dashboards are size and typography presets only — no compliance with any journal's requirements is claimed.

# 13. Financial Modeling

DCF valuation template
DCF valuation template: named assumptions, WACC, terminal value, equity bridge, sensitivity grid.
DCF builder output
The DCF builder writes a complete model as live formulas (inputs blue, formulas black).
Loan amortization
Amortization schedules computed in decimal arithmetic, to the cent.
Bond analytics
Bond price, yield, duration, convexity and the price–yield curve.
  • 49 financial worksheet functions (PMT … XIRR, depreciation, and the security functions with all five day-count bases), validated on 68,075 Excel-computed values
  • Financial Modeling Studio: time value of money, loan and Canadian mortgage schedules, bond analytics, cash-flow analysis listing all IRR roots, capital budgeting, DCF builder, portfolio analytics, ratios, break-even, forecasting
  • What-if tools: goal seek, one- and two-variable data tables, scenario manager, tornado sensitivity, Monte Carlo on the live model (seeded, with correlated inputs) — all computed on an isolated copy so the workbook and its undo history are untouched until you apply a result
  • every tool shows its conventions: payment timing, compounding, day count, rounding. Excel-compatible and alternative conventions are both available where they differ and are named for what they are (docs/mathematics/financial-conventions.md)

Monte Carlo simulation on a model

# 14. Statistics

Statistics Studio: linear regression with robust standard errors

Statistics Studio offers 27 analyses on worksheet ranges: descriptive summaries, histograms, correlation matrices; confidence intervals, t and z tests, chi-square tests, one- and two-way ANOVA with Tukey HSD, variance and normality tests, non-parametric tests; OLS and WLS with classical, HC0–HC3, HAC and clustered errors and a full diagnostics table; fixed-effects panel regression; logistic regression; ACF/PACF, exponential smoothing, ARIMA, GARCH(1,1), ADF; PCA, k-means, hierarchical clustering; bootstrap and permutation tests. Each result states the statistic, degrees of freedom, p-value, effect size and assumptions, and can be written to the sheet as a formatted report.

Every method is validated against SciPy, statsmodels, scikit-learn, linearmodels or arch; the tolerance achieved per method is tabulated in Packages/SheetAnalytics/VALIDATION.md, together with the methods that were not shipped because they could not be validated.

# 15. Python Studio

Python Studio
Editor, console, DataFrame previews, captured matplotlib figures, pending changes and run history.
Consent sheet
A script that arrived with a workbook never runs without this review.
python
import orix

sheet = orix.active_sheet()
data = sheet.range("A1:D100").to_dataframe()
result = data.groupby("Category")["Revenue"].sum()
sheet.range("F1").write(result)

This example runs as written (it is a test). Python is a separate process of an interpreter found on the Mac (nothing is bundled); values travel as JSON over private pipes; writes are buffered and applied as one undoable step when the run succeeds.

Restricted mode is on by default and wraps the interpreter in a sandbox profile. What it enforces is verified by tests on this macOS version: no network (TCP, UDP, listening), no writes outside the run folder, no reads under /Users, /Volumes or /tmp, no other program can be launched, no signals to other processes; CPU, file-size and open-file limits, a wall-clock timeout, an output cap and termination of the whole process tree. What it does not enforce is stated just as plainly in the app and in Packages/SheetPython/SECURITY.md (for example, there is no hard memory limit on macOS). If the sandbox is unavailable the run is refused — it never silently falls back. Every run is recorded in a local audit log.

Measured: reading 100,000 rows × 6 columns into a DataFrame takes 0.40 s and writing them back 0.55 s (debug build).

# 16. Local AI

ORIX Intelligence suggesting formulas, each validated by the engine

ORIX Intelligence uses Apple's on-device Foundation Models when the Mac supports them. There is no cloud model and no network code. When the model is unavailable the panel says why and the rest of the app is unaffected.

The model never calculates. It explains formulas from the engine's real evaluation steps, describes data from deterministic column profiles, prioritizes the auditor's findings (it cannot invent one), and suggests formulas — each of which is parsed, checked against the function registry and evaluated by the real engine on a copy of the workbook before it is shown, with the computed value next to it.

Measured on this machine against 20 fixed requests: every request received at least one formula that validates, and 12 of 20 received a formula that computes the expected value. "Valid" therefore means "computes", not "is what you meant", and the panel says so. Source: Packages/SheetIntelligence/EVALUATION.md.

# 17. Formula Intelligence

Step-by-step formula evaluation
Step-by-step evaluation: every intermediate value comes from the evaluator.
Dependency graph
Dependency graph of a cell: precedents left, dependents right, cycles marked.

Autocomplete for functions, names, tables and sheets; signature and active-argument hints while typing; coloured reference outlines; plain-language structure description; error explanations that trace an error to its origin; comparison with neighbouring formulas; a browsable catalogue of every function.

# 18. Model Auditor

Model Auditor findings

21 rules: error values with their root cause, broken references, circular dependencies with the cycle path, formulas inconsistent with their row or column, hardcoded constants and overwritten formulas, hidden rows and sheets holding data, references to blanks, numbers stored as text, mixed types in a table column, volatile functions, long formulas, unused and broken names, external links, and more. Each finding has a severity, evidence, an explanation and a recommended action; not every hardcoded value is treated as an error. Findings can be ignored (stored in the workbook), exported as Markdown or inserted as a sheet.

# 19. Automation

Automation: a finished workflow run

  • Visual workflows — 25 step kinds (import, clean, transform, SQL, formulas, pivot, chart, validate, export, save, batch over a folder, run an approved Python script), parameters, per-step error policy, live progress, cancellation and history. A run works on a copy; outputs are staged and moved into place only on success; applying a run to the open workbook is one undo step.
  • Command line — orix-sheet ships inside the app bundle: convert, recalc, eval, info, audit, sql, run, functions.
    console
    $ orix-sheet eval sales.xlsx '=SUM(C:C)'
    20076.81
    $ orix-sheet convert sales.csv sales.pdf
    Wrote sales.pdf (pdf, 2 pages)
  • Shortcuts — App Intents for Convert Spreadsheet, Recalculate Workbook, Run ORIX Workflow and Get Cell Value. They compile and their logic is tested; their appearance in the Shortcuts app has not been verified yet.
  • Scheduling — the app shows the exact command and can install a per-user LaunchAgent on request. Nothing is scheduled without that explicit step.

There is no network listener and no remote API. AppleScript is not implemented.

# 20. Import & Export

Format Read Write Notes
.orixsheet (native) ✓ ✓ lossless, integrity-checked
.xlsx ✓ ✓ values, formulas, styles, number formats, merges, names, tables, conditional formats, validations, notes, links, freeze panes, print settings
.xlsm ✓ ✓ macros are never executed; the VBA project is carried through untouched
.ods ✓ ✓ values, formulas, basic styles, merges, sizes, notes, links
.csv / .tsv ✓ ✓ delimiter and encoding detection; fields starting with = stay text
.json / .jsonl ✓ ✓ arrays of objects or arrays
.parquet, SQLite, DuckDB files data engine export through Data Studio
PDF — ✓ paginated, vector
.xls, .xlsb, Numbers — — recognised and refused with a clear message

No silent data loss. A foreign file is imported into an untitled ORIX workbook — the original is never overwritten — and an import report lists what changed. Writing another format is an explicit Export, preceded by a compatibility report of everything that format cannot hold. Charts, pivots, images and other parts of an XLSX that ORIX does not model are preserved byte-for-byte and written back.

Archives are read by a hardened ZIP reader (path traversal, entry count, size and compression-ratio limits; CRC checks). External links are never fetched.

Measured, 1,000,000 cells (release build): native read 0.10 s / write 0.58 s; XLSX read 1.90 s / write 1.19 s; CSV read 0.19 s. Source: Packages/SheetIO/COMPATIBILITY.md. Full matrix: docs/compatibility/formats.md.

# 21. Native Workbook Format

.orixsheet is a document package: a manifest with a SHA-256 per part, JSON metadata, zlib-compressed binary cell chunks per sheet, and attachments (scripts, pipelines, workflows, scenarios, preserved foreign parts). Saving is atomic; a damaged part is named precisely and the other sheets still load. Round-tripping random workbooks is bit-exact and re-saving is byte-stable (property tests). Autosave and versions come from the macOS document system. Specification: Packages/SheetIO/NATIVE-FORMAT.md, docs/architecture/persistence.md.

# 22. Architecture

flowchart LR
  subgraph App["ORIX Sheet.app"]
    Doc[WorkbookDocument<br>NSDocument] --> Session[WorkbookSession<br>main actor]
    Session --> Grid[GridView<br>AppKit + CoreText]
    Session --> Panels[Feature panels<br>SwiftUI]
  end
  Session --> Engine[CalcEngine<br>dependency graph]
  Engine --> Core[SheetCore<br>model · parser · evaluator]
  Engine --> Fn[Function libraries<br>473 functions]
  Panels --> Data[SheetData<br>DuckDB]
  Panels --> Charts[SheetCharts<br>vector renderer]
  Panels --> Stats[SheetAnalytics]
  Panels --> Py[SheetPython<br>subprocess]
  Panels --> AI[SheetIntelligence<br>on device]
  Doc --> IO[SheetIO<br>xlsx · ods · csv · native]

SVG version of this diagram: docs/assets/diagrams/readme-architecture.svg.

The calculation engines are Swift packages with no dependency on SwiftUI or AppKit views; the app is a thin layer that registers features into a workspace. Ten diagrams (grid rendering, parsing, dependency graph, calculation scheduling, data engine, Python integration, chart rendering, persistence, import/export, AI) are in docs/architecture/, each as Mermaid with an SVG fallback in docs/assets/diagrams/.

Document Subject
overview packages, threading, extension points
grid-engine virtualized grid and printing
formula-engine · calculation-graph parser, evaluator, recalculation
data-engine DuckDB embedding, transforms, pivots
python-runtime subprocess, sandbox, RPC
chart-engine charts and figures
persistence native format and documents
intelligence on-device assistance
security threat model

# 23. Technology Stack

Layer Technology Why
Language Swift 6 (strict concurrency) one language from engine to UI
UI SwiftUI for chrome and panels, AppKit for the grid, editors and documents native behaviour; a view per cell is not viable
Rendering CoreGraphics + CoreText repaint is a few milliseconds; a Metal text renderer was evaluated and not needed
Numerics Accelerate (LAPACK, vDSP), own special functions on every Mac, validated against SciPy
Analytics DuckDB 2.0.1 through its C API columnar, out-of-core, MIT licence
Files own OOXML/ODF readers and writers on zlib control over safety and fidelity
Python subprocess + sandbox-exec isolation; nothing to bundle
AI Apple Foundation Models (weak-linked) on device, optional

The reasoning and the alternatives considered are in docs/research/technology-evaluation.md; the product positioning in docs/research/competitive-analysis.md. There is no third-party Swift dependency.

# 24. Installation

Requirements: macOS 14 or later (Apple Silicon or Intel; developed and measured on Apple Silicon). Python Studio needs a Python 3.9+ installation; ORIX Intelligence needs a Mac and macOS version with Apple Intelligence.

  1. Download ORIXSheet-1.0.0.dmg, open it and drag ORIX Sheet to Applications.
  2. Launch it. There is nothing to configure and no account.

The distribution status of the current build (signature, notarization, checksums) is under Release status.

# 25. Build Instructions

bash
brew install xcodegen create-dmg          # build tools
Scripts/fetch-duckdb.sh                    # pinned DuckDB library, checksum verified
Scripts/build.sh generate                  # ORIXSheet.xcodeproj from project.yml
Scripts/build.sh debug && Scripts/build.sh run

Xcode 27 / Swift 6.4 were used. Every package also builds on its own with swift build. Release: Scripts/sign.sh (universal build, Developer ID, hardened runtime), Scripts/notarize.sh (notarytool, stapling, packaging), described in docs/release/. Setup details: docs/development/setup.md.

# 26. Testing

Package Tests Status
SheetCore 32 passed
SheetFormat 28 passed
FunctionsNumeric 31 passed
FunctionsText 19 passed
FunctionsLookup 49 passed
SheetEngine 4 passed
SheetIO 66 passed
SheetCharts 43 passed
SheetData 64 passed
SheetAnalytics 310 passed
SheetPython 57 passed
SheetIntelligence 62 passed
SheetAutomation 78 passed
SheetTemplates 29 passed
SheetUI 20 passed
FeatureAudit 60 passed
FeatureCharts 51 passed
FeatureData 57 passed
FeatureAnalysis 125 passed
FeaturePython 40 passed
FeatureIntelligence 17 passed
FeatureAutomation 28 passed
ORIXSheetTests (hosted in the running app) 9 passed
Total 1,279 all passing

Run of 2026-11-21T08:47:01Z on the build machine. Source: docs/reports/tests.json, docs/reports/app-tests.json.

The counts above are test functions; many are parameterized over fixture files, so the number of reference cases checked is far larger (see Formula engine). The app-hosted suite drives real documents and windows: typing through the grid's key handling, mouse selection, undo through the document, native save and reopen, import-as-untitled, export preflight, corrupted files, paginated vector PDF, and a 200,000-cell sheet recalculated in the background.

Not automated: there is no XCUITest target, so menus, drag and drop, file panels and popovers are exercised only through their models. VoiceOver has not been listened to. Line coverage has not been measured. Strategy and commands: docs/development/testing.md.

# 27. Benchmarks

Engine, release build, Apple M5 Max (18 cores, 48 GB), macOS 27.0 — swift run -c release orix-bench:

Scenario Time
Parse 500,000 formulas 0.53 s
Full recalculation, 80,000 formulas (120,000 cells) 0.095 s
Full recalculation, 800,000 formulas (1.2 M cells) 1.21 s
Full recalculation, 4,000,000 formulas (6 M cells, 4.5 GB resident) 5.01 s
Incremental recalculation after one edit, 6 M-cell workbook 0.1 ms
Chain of 1,000,000 dependent formulas 0.39 s
7 whole-column aggregates over 1,000,000 rows 0.54 s
Format 2,000,000 numbers as #,##0.00 0.29 s
Insert 5 rows + recalculate, 1.2 M cells 3.08 s
Sort 100,000 rows × 4 columns + recalculate 2.52 s

Source: docs/benchmarks/engine.json. These are benchmark scenarios on one machine, not guaranteed workloads. Slow paths are visible in the table: structural edits rebuild the dependency graph and recalculate everything, and memory is about 750 bytes per formula cell. No comparison with any other product is made. All tables: docs/development/performance.md.

# 28. Excel Compatibility

What is validated: formula semantics function by function (above), XLSX round trips checked by two independent readers (openpyxl and LibreOffice), and the templates recalculated end to end by LibreOffice.

What differs from Excel, by design or for now:

  • a circular reference shows #CIRC! (Excel warns and shows 0); iterative calculation is not supported
  • no 3-D references (Sheet1:Sheet3!A1), no reference union or intersection operators, no R1C1 entry, no external-workbook formulas (their cached value is kept on import, with a notice)
  • whole-column references are clamped to the used rows when materialized
  • function names are English in every locale; separators follow the region
  • VBA is never run; pivot tables, charts and images in an XLSX are preserved but not editable as Excel objects; ORIX charts are not exported to XLSX yet (announced by the export report)
  • text ordering uses a fixed collation rather than the system locale
  • several keyboard shortcuts differ (⌘ instead of Ctrl, ⌘= recalculates, ⌃G goes to a cell)

The complete list, verified against the code: docs/compatibility/excel.md.

# 29. Privacy

  • No account, no registration, no advertising, no analytics, no telemetry.
  • The application contains no network code in its calculation, file, chart, data or AI paths. The embedded DuckDB cannot load extensions or reach the network.
  • The single network use is pip install, run only when you ask for it in Python Studio and confirm it.
  • Python scripts and workflows that arrive inside a workbook never run on open; they must be reviewed and approved, and approvals are tied to the exact text.
  • On-device AI receives a bounded, documented context (headers, types, a few sample rows); see Packages/SheetIntelligence/PRIVACY.md.
  • The app is not sandboxed (Python's own sandbox cannot nest inside the App Sandbox); it uses the hardened runtime with no entitlements.

Threat model: docs/security.md.

# 30. Accessibility

Labels on every control (verified through the system accessibility API: 0 unlabelled controls in the audited panes); grid cells exposed with row and column header context; keyboard access to the chrome; Reduce Motion, Increase Contrast and Differentiate Without Colour are honoured; a default zoom preference; colour-blind-safe chart palettes; text and UI contrast measured against WCAG and corrected (table in docs/development/accessibility.md).

Honest status: VoiceOver has not been listened to by a person, performAccessibilityAudit() has not been run, and embedded objects and row/column headers are not yet accessibility elements.

# 31. Localization

English and Canadian French. 557 strings in the shared interface and the app, plus each feature's own catalogue (about 4,500 more), all translated and checked by scripts for missing keys and mismatched format specifiers. Numbers, dates, currency and formula separators follow the region; the stored formula is locale-independent. Text produced by the engines (audit explanations, statistical notes, function summaries) is English for now. Details: docs/development/localization.md.

ORIX Sheet in Canadian French

# 32. Roadmap

Planned next, none of it promised by this release: multi-threaded recalculation; dirty-rectangle grid drawing; incremental graph updates for structural edits; chart export to XLSX; in-grid text rotation and rich text; iterative calculation; XCUITest coverage; signed automatic updates (Sparkle was evaluated and is not included); AppleScript dictionary.

# 33. Release Status

Version 1.0.0 (2), built on 21 November 2026. Evidence for every line is in RELEASE-REPORT.md and docs/reports/.

Item Status
Universal Release build (arm64 + x86_64) built
Signature Developer ID Application: Simon-Pierre Boucher (3YM54G49SN), hardened runtime, secure timestamp
Apple notarization Accepted — app 2c7463bf-26a6-49f2-8d29-250a664f487e, disk image 824f9e74-d90b-409d-a5e4-cf9034581b5a
Stapling and Gatekeeper stapled; spctl reports Notarized Developer ID for the app, the DMG and the app extracted from the ZIP
ORIXSheet-1.0.0.dmg 80,310,380 bytes · SHA-256 04867c73714939249c1f2f19d085102932308765d29a7188dcd445a78231f861
ORIXSheet-1.0.0.zip 79,521,512 bytes · SHA-256 576bc7dc3776f7893c21aaaf5abe76be17cc2e3c7fce8d39f70658491a644455
Source public: https://git.spboucher.ai/orix-sheet, tag v1.0.0 (published on 21 November 2026 at the owner's request)
Release https://git.spboucher.ai/orix-sheet/releases — DMG · ZIP · SHA256SUMS · notes

The published DMG and ZIP were downloaded back from the forge and verified: checksums match, the disk image is stapled and Gatekeeper reports Notarized Developer ID.

Only the Apple Silicon slice on macOS 27.0 has been run; the Intel slice and macOS 14–26 are untested.

# 34. Known Limitations

  • Calculation: single-threaded; structural edits (insert/delete rows or columns, sheet operations) rebuild the dependency graph and recalculate the workbook; about 750 bytes of memory per formula cell.
  • Grid: no text rotation, shrink-to-fit or rich text in cells; objects and overflowing text are clipped at frozen-pane boundaries; no split panes; full-window repaint on every change.
  • Excel: see section 28. .xls and .xlsb are not read.
  • Charts: not exported to XLSX; the 3D surface is a static projection; automatic chart labels are English.
  • Pivots: values are numeric; subtotals are all on or all off; a pivot's anchor is not updated when rows are inserted above it.
  • Data: datasets are linked, not embedded — they are re-imported from their source when a workbook is reopened; large inserts into a sheet run on the main thread (about 0.85 M cells/s).
  • Python: requires an installed interpreter; no hard memory limit; "insert plot into sheet" is not available.
  • AI: formula suggestions are right about 60 % of the time on the measured set; Python suggestions are only syntax-checked.
  • Automation: Shortcuts discovery and LaunchAgent installation have not been exercised in an installed build; AppleScript is absent.
  • Testing: no UI-automation target; coverage not measured; Microsoft Excel was never driven as a reference.
  • Distribution: no automatic updates.

# 35. ORIX Ecosystem

ORIX is a family of premium Apple utilities built on the same principles: instant utility, professional precision, privacy by design, local-first computing. ORIX Sheet shares the family's visual language — navy canvas, cyan-to-indigo accent, the ORIX ring — without any runtime dependency on the other applications (ORIX Scan, ORIX Calc, ORIX Audio, ORIX Monitor, ORIX Clean, ORIX Secure, ORIX Camera). Icon exploration: docs/design/icon-design.md.

Five icon concepts and the final icon

# 36. License

© 2026 Simon-Pierre Boucher. All rights reserved. The source is published for reading; no licence to reuse it is granted.

Third-party components: DuckDB (MIT) is embedded as an unmodified binary. Test fixtures include reference values derived from the ExcelFinancialFunctions project (Apache-2.0); attribution is in Packages/FunctionsLookup/COMPATIBILITY.md. No other third-party code is linked.


ORIX Sheet — Beyond Spreadsheets.

Files main
Menu

Theme