# LSD.tools

> LSD is a visual platform for data pipelines you can see, collaborate on, and extend — with live 3D, deep learning, and an extensible package ecosystem.

## Use cases
- [A live energy twin of a university campus](https://lsd.tools/use-cases/campus-energy-twin): Join a live meter feed to 85 campus building meshes, aggregate it hourly, and paint a 3D heat-map that repaints as energy use shifts, plus a weekly report.
- [A churn model whose features you can actually see](https://lsd.tools/use-cases/churn-feature-pipeline): Build churn features from Postgres events and Parquet snapshots, catch a leaky window visually, and score the holdout with ONNX — on one canvas.
- [From CMM points to a 3D deviation report](https://lsd.tools/use-cases/cmm-deviation-report): Align CMM measurement points to a nominal CAD mesh, compute point-to-surface deviation, and export a color-mapped glTF model with a pass/fail report.
- [Segmenting organs from CT series with ONNX](https://lsd.tools/use-cases/ct-organ-segmentation): Turn a CT DICOM series into an ONNX organ segmentation you QA in 3D, then export an annotated volume and a per-organ volumetrics report.
- [Flood-risk mapping from LiDAR and rainfall rasters](https://lsd.tools/use-cases/flood-risk-mapping): Turn LiDAR terrain, rainfall GeoTIFFs, and a drainage Shapefile into a flood-risk raster, a 3D flyover, and a district report — live sliders, no scripts.
- [Groundwater flow at mine-closure time scale](https://lsd.tools/use-cases/groundwater-mine-closure): Model post-closure pit-lake rebound in LSD — krige borehole heads against a NetCDF recharge grid and deliver a live 3D drawdown model plus report.
- [Reducing a season of spectrometer runs, reproducibly](https://lsd.tools/use-cases/spectrometer-batch-reduction): Reduce 900 spectrometer CSVs against a calibration NetCDF into publication-ready spectra and a reproducible dataset export — no scripts.
- [Detecting surface defects on an aluminium line](https://lsd.tools/use-cases/surface-defect-detection): Turn folders of line-scan images and a label CSV into an ONNX defect-segmentation pipeline with overlay QA and a per-coil defect report.
- [Exploring a wind-turbine wake from 200 GB of CFD output](https://lsd.tools/use-cases/turbine-wake-analysis): Slice 200 GB of NetCDF CFD output into live wake planes and iso-surfaces, then export an animated wake visualization and a downstream-loss table.
- [Building a warehouse occupancy map from LiDAR sweeps](https://lsd.tools/use-cases/warehouse-lidar-map): Turn raw LAS/LAZ sweeps from a mobile robot into a nav-ready occupancy grid and 3D map — registration to export with zero scripts.
- [Land-cover maps from aerial imagery](https://lsd.tools/use-cases/aerial-landcover-segmentation): Turn GeoTIFF orthomosaics into a stitched land-cover raster with per-class area stats, using tiled ONNX segmentation you can preview at every step.
- [Streaming bridge strain gauges into a 3D twin](https://lsd.tools/use-cases/bridge-strain-twin): Calibrate live strain telemetry, place gauges on the bridge mesh from a CSV, and color the structure by stress live — plus an alert log on every exceedance.
- [Slicing a 40-member climate ensemble into regional anomaly maps](https://lsd.tools/use-cases/climate-ensemble-slices): Crop 40 NetCDF ensemble members to a region, aggregate by season, and difference against a baseline — small-multiple maps and a per-region CSV.
- [From drillhole logs to a live 3D lithology model](https://lsd.tools/use-cases/drillhole-lithology-model): Validate 63 LAS drillhole logs against collar surveys, krige a lithology block model, and export one glTF the whole team can open.
- [QA-ing robot telemetry before a field trial](https://lsd.tools/use-cases/field-trial-telemetry-qa): Sync CSV sensor logs with live REST telemetry, flag outliers and dropouts, and score every robot pass/fail before the field trial.
- [QA-ing an MRI research cohort before analysis](https://lsd.tools/use-cases/mri-cohort-qa): Screen 400 MRI studies before analysis: harmonize metadata, check orientation and spacing, flag motion, and export a pass/fail QA table and exclusion list.
- [Batch-scoring a million rows with an ONNX model](https://lsd.tools/use-cases/onnx-batch-scoring): Score a million-row Parquet batch with an ONNX model — training-identical normalization, live previews, scored Parquet and metrics out.
- [Joining 80k parcels to zoning without a single script](https://lsd.tools/use-cases/parcel-zoning-join): Spatially join 80,000 parcels to zoning polygons from PostGIS, flag conflicts, and export styled map layers plus a clean planning file — no scripts.
- [Catching sensor drift across a production week](https://lsd.tools/use-cases/production-sensor-drift): Resample a week of machine sensor logs, baseline each tag, and flag drift and step changes on a live dashboard with a ranked maintenance shortlist.
- [Statistics over a 200-sensor array without notebook drift](https://lsd.tools/use-cases/sensor-array-statistics): Turn long-run logs from a 200-sensor array into windowed stats with uncertainty — cleaned, aligned, and delivered as a per-sensor summary anyone can re-run.

## Docs
- [lsdtools API reference](https://lsd.tools/docs/api-index): The complete lsdtools v1 public API, grouped by task — authoring, data, runtime, views, packaging, meta. Import only lsdtools; API version 2.1.
- [Example: your first tool](https://lsd.tools/docs/ex-hello-tool): A complete, runnable package with one load step and one shape step — the smallest tool that shows up on the LSD canvas. Copy, run, and adapt.
- [Package anatomy](https://lsd.tools/docs/pkg-anatomy): An LSD package is a folder: an lsd_package.json manifest plus a Tool. Learn every v1 field, the code and tool keys, and the folder layout.
- [What is LSD?](https://lsd.tools/docs/start-overview): LSD turns Python functions into cached, inspectable pipeline nodes you assemble on a visual canvas — author with lsdtools, run anywhere.
- [The Tool object](https://lsd.tools/docs/tools-tool-object): Every LSD package has one Tool at module scope — it names your nodes, collects each decorated step, and mounts them into the host at load.
- [Everything you show is a View](https://lsd.tools/docs/ui-overview): The show side of LSD is one declarative View class: with a kind it represents data, with no kind it collects input, and show() presents either. None import GTK.
- [Tool](https://lsd.tools/docs/api-tool): Tool is the one object per package you decorate functions with to make LSD nodes, commands, and views. Reference for every decorator and method.
- [Example: clean a CSV](https://lsd.tools/docs/ex-clean-csv): Load a CSV through a Source, drop bad rows, rename and sort columns, print a null report, then write a clean CSV — a full three-step pipeline.
- [Develop a package](https://lsd.tools/docs/pkg-develop): Scaffold a package with lsd package new, add it to the desktop by reference for live edits, and reload to pick up changes as you author.
- [How an LSD package fits together](https://lsd.tools/docs/start-architecture): The mental model behind LSD — everything the Engine holds is either something you run (an entity's pipeline) or something you show (a view).
- [Parameters vs ports](https://lsd.tools/docs/tools-params-ports): The one classification rule behind every LSD node — how a step's parameters split into input ports, injected context, and form fields, all checked at import.
- [A View of params and actions](https://lsd.tools/docs/ui-panels): The base View — param() fields plus @action buttons, no kind — collects input and drives actions. Author it with @tool.view; location= only sets where it shows.
- [Context](https://lsd.tools/docs/api-context): StepContext and Context are what LSD injects into your functions — progress, cancellation, outputs, plus the host, engine, project, and UI slots.
- [Example: file loader](https://lsd.tools/docs/ex-file-loader): A @tool.load that reads a file or SQL query and maps the user's columns onto canonical x/y/z with a columnmap parameter and auto-detect.
- [Dependencies](https://lsd.tools/docs/pkg-dependencies): Declare dependencies as name to version-spec pairs (*, X.Y.Z, >=X.Y.Z). See how LSD resolves them and reports what needs what.
- [Install LSD](https://lsd.tools/docs/start-install): Install the lsdtools SDK with pip, get the Windows desktop app, and point the CLI at a backend — everything you need to build and run pipelines.
- [Tables & data flow](https://lsd.tools/docs/tools-tables): A Table is the immutable value that flows between LSD nodes. Chain verbs that return new tables, and drop to .arrow for raw pyarrow when you need it.
- [Data views represent data](https://lsd.tools/docs/ui-widgets): A data view renders data as a table, chart, or flowchart via to_text()/to_image(). Feed it, return one from @tool.view, and present it with show().
- [Source](https://lsd.tools/docs/api-source): Source is the input a load step reads — files, a folder with globs, or a SQL query the user picks. Reference for Source.file, Source.sql, Source.of, and read.
- [Example: multi-output mesh](https://lsd.tools/docs/ex-multi-output): A load step that emits a cube as two tables — vertices and faces — via outputs=[...], then wires one named output into a downstream shape.
- [The Package Manager](https://lsd.tools/docs/pkg-manager): The desktop Package Manager: filter In Project, Installed and Store, freeze packages per project, pick variants, and add from a URL.
- [Run your first pipeline](https://lsd.tools/docs/start-first-pipeline): Build a Load · Shape · Deliver pipeline on the LSD canvas with no code — add nodes, wire them, run, and watch caching skip the work that didn't change.
- [Load steps](https://lsd.tools/docs/tools-load): A @tool.load node produces a Table from parameters or a Source the user picks — the entry point of every pipeline. Learn its signature and Source injection.
- [Custom views](https://lsd.tools/docs/ui-custom-views): Subclass View to render your own data: set kind, implement feed() and to_text()/to_image(), and register the GTK shell with set_view_shell.
- [Table](https://lsd.tools/docs/api-table): Table is lsdtools' immutable, zero-copy wrapper over an Arrow table — the data that flows between steps. Reference for every method, with examples.
- [View](https://lsd.tools/docs/api-view): View is the one presentable surface in LSD — param() fields, @action buttons, and optional data. Reference for watch, feed, show, and state.
- [ViewerPayload](https://lsd.tools/docs/api-viewerpayload): ViewerPayload is what a viewer-delivering @tool.deliver returns — a JSON spec plus Arrow tables. Covers LayerPayload, ChartPayload, and LegendPayload.
- [Publish to the store](https://lsd.tools/docs/pkg-publish): Publish a package to the LSD store: seal the code into a signed .lsdpkg, upload a version, and let buyers verify and trust it.
- [Write your first tool](https://lsd.tools/docs/start-first-tool): Turn a Python function into a live canvas node in ten lines with lsdtools — scaffold a package, add a step, and watch it hot-load into the palette.
- [Shape steps](https://lsd.tools/docs/tools-shape): A @tool.shape node transforms data — one or more Table input ports in, a Table out. Learn its signature and how to combine several inputs into one.
- [Column](https://lsd.tools/docs/api-column): Column is a lazy, whole-column expression you build with Python operators, then pass to Table.filter or Table.with_column. Reference with the operator table.
- [Engine](https://lsd.tools/docs/api-engine): Engine runs pipelines in Python — ephemeral, from a .lsd file, or a project dir. Reference for add, run, save, load, and the RunResult it returns.
- [RunResult](https://lsd.tools/docs/api-runresult): RunResult is the friendly result of Engine.run — its .ok flag, .output Table, .outputs dict, plus .print() and .raise_on_error() for tests.
- [Example: live node metrics](https://lsd.tools/docs/ex-graph-outputs): Show live row and column counts on a node card with graph_outputs and ctx.set_output, plus progress reporting via StepContext.progress.
- [Plans & licensing](https://lsd.tools/docs/pkg-plans-licensing): Price a paid package: one-time or subscription plans, concurrent seats bought by quantity, offline leases, and sealed/source/server delivery.
- [Where to go next](https://lsd.tools/docs/start-where-next): A map of the LSD docs — from building tools and UI to packaging, publishing, guides, examples, and the full lsdtools API reference.
- [Deliver steps](https://lsd.tools/docs/tools-deliver): A @tool.deliver node is the pipeline's exit — a Table in, and either a side effect (a written file) or a ViewerPayload the framework shows in the viewer.
- [Runtime](https://lsd.tools/docs/api-runtime): Runtime describes an installed LSD product — its install dir, CLI, GUI, and Python paths. Reference for find_runtime and the API_VERSION constant.
- [Example: drag-drop import](https://lsd.tools/docs/ex-import-template): A drag-drop import template — dropping a .csv builds a pre-wired entity via @tool.template and an @tool.entity builder function.
- [Buy & install](https://lsd.tools/docs/pkg-store-install): Browse the store, buy a package in your browser, then Open in LSD to install it — and see its owned and installed states in the app.
- [Multiple outputs](https://lsd.tools/docs/tools-multi-output): Emit several tables from one node with outputs=[...] and wire each with step.output('name'). Add graph_outputs for live read-only scalars on the card.
- [Rendering & payloads](https://lsd.tools/docs/tools-rendering): How a deliver step shows geometry, a chart, or a legend — return a ViewerPayload and the framework persists and routes it to the view that watches the entity.
- [Example: a dockable panel](https://lsd.tools/docs/ex-panel): A complete @tool.view that returns a View — a param() field plus an @action button that calls self.ctx.ui.notify. Runs headless too.
- [Collaboration & seats](https://lsd.tools/docs/pkg-collab-seats): The host runs the engine and guests join. When connected devices exceed a package's seats, the host freezes it and shows a banner.
- [Entity types](https://lsd.tools/docs/tools-entities): A @tool.entity is a creatable node type — a container with its own form and pre-wired child steps. Declare one with a builder function or an Entity subclass.
- [Example: a CLI command](https://lsd.tools/docs/ex-cli-command): Turn a typed function into an `lsd csvkit stats` CLI command with @tool.command — required args become positionals, defaults become options.
- [Node variants](https://lsd.tools/docs/tools-variants): Make one node a drop-in variant of another with overrides='pkg.node'. Pick override_mode='replace' to win the identity, or 'coexist' to offer both.
- [PackageManager](https://lsd.tools/docs/api-package-manager): PackageManager is the desktop-side API behind the Package Manager — list, install, enable, disable, and inspect packages. Reference for every method.
- [Example: a node variant](https://lsd.tools/docs/ex-variant): A second provider for one node identity — @tool.load(overrides=..., override_mode="coexist") plus the Package Manager variants dropdown.
- [Commands & actions](https://lsd.tools/docs/tools-commands-actions): Add a CLI subcommand from a typed function with @tool.command, and route menu or context actions with @tool.action — then invoke them via tool.dispatch.
- [lsd_package.json](https://lsd.tools/docs/api-manifest): lsd_package.json is the manifest that makes a folder an LSD package. Full field table, the version-spec grammar, sealed and paid fields, and file paths.
- [Example: a complete package](https://lsd.tools/docs/ex-full-package): The anatomy of a shippable package — a load, shape and deliver step, a CLI command, a dockable panel, and its lsd_package.json manifest.
- [Contributing UI with @tool.view](https://lsd.tools/docs/tools-panels-overlays-views): One decorator, @tool.view, contributes UI. It always returns a View; location= (sidebar / overlay / editor) is only where the View lands. Nothing imports GTK.
- [CLI commands](https://lsd.tools/docs/api-cli): The lsd CLI scaffolds and lints packages, runs your tool commands, and describes the API for an AI editor. Reference for every command with usage blocks.
- [Naming: which is which](https://lsd.tools/docs/tools-glossary): A few LSD words carry more than one meaning — View, panel, table, workspace, entity. This page pins each to its exact meaning.
- [Errors](https://lsd.tools/docs/api-errors): ValidationError and SchemaError are the two typed failures lsdtools surfaces at run time — a rejected parameter, or a step's output schema mismatch.
- [describe_api](https://lsd.tools/docs/api-describe): describe_api returns machine-readable JSON of every registered step and the public surface. Reference for describe_api, describe_text, and describe_markdown.
- [lsdtools.advanced](https://lsd.tools/docs/api-advanced): lsdtools.advanced is the escape hatch to lsd internals — four honest reasons to reach in, and the grouped names it exposes. Use it sparingly.

## News
- [A curated model catalog: ONNX inference on LSD](https://lsd.tools/blog/onnx-model-hosting): Pick a hosted ONNX model from LSD's catalog and run it as a pipeline step — curated models, a clear per-run price, wired straight into the graph.
- [Tool Store v2: reviews, ratings, and web checkout](https://lsd.tools/blog/tool-store-v2): The Tool Store grows up — a real review pipeline for publishers, ratings and reviews on every listing, and buy-on-the-web-install-in-the-app checkout.
- [The docs, rebuilt: a linear journey with Ctrl+K search](https://lsd.tools/blog/docs-revamp-search): We rebuilt the docs into one linear journey across six categories, added a Ctrl+K search palette, and gave every page a plain-markdown view for AI agents.
- [Twenty real pipelines — and a dex to explore them](https://lsd.tools/blog/use-case-dex): We shipped twenty step-by-step use-case tutorials across ten fields, plus a landing-page dex of highlighted pipeline nodes you can browse and deep-link.
- [Platform roundup: realtime notifications, instant sign-in, cookieless analytics](https://lsd.tools/blog/platform-roundup): Three smaller wins: realtime notifications, instant one-tap sign-in, and first-party analytics with no cookies and no third-party trackers.
- [Introducing LSD — a visual platform for data pipelines](https://lsd.tools/blog/introducing-lsd): LSD is a visual operating system for data: Load, Shape, and Deliver pipelines on one canvas — with live 3D, deep learning, and extensible packages.

## Tool Store
- [Geo Toolkit](https://lsd.tools/store/geo-toolkit): The Geo Toolkit package adds geoscience loaders (LAS, SEG-Y, collar surveys) and horizon-interpolation steps to LSD for building 3D subsurface models.
- [ONNX Runner](https://lsd.tools/store/onnx-runner): ONNX Runner runs ONNX models as a step inside an LSD pipeline — wire inputs from upstream entities and feed predictions downstream, with caching.