Features

A reference of what Ditaro can do today, organised by area.

Project workspace

• Open project. Point at any directory. There's no project file to create or maintain; the folder is the project. The left pane shows it as a live filesystem tree.
• New project. File > New Project creates the folder — optionally initialised as a git repository — and opens it, ready for a first topic. A plain directory, nothing else: no metadata, no lock-in.
• Recents. File > Recents and the toolbar Open dropdown surface the last few projects.
• Project tree. Folders, files, and type badges for DITA topics, maps, and ditavals. Git status decorates added / modified / untracked files inline.
• Map outline. Walks mapref chains across ditamaps (cycle-safe), inlines bookmap structure, and labels branched ditavalref nodes by scope.
• Saving that helps. Save As suggests a filename taken from the document's title for new files, and a bare name you type gets the right DITA extension appended.
• Naming, your way. Generated file names and ids follow your preferred casing — kebab-case or snake_case, set separately for each in Preferences. Refactor > Normalize Naming converts an existing project.
• Auto-save. Optionally save your work after a configurable pause in typing. Off by default, and it never touches files you haven't named yet.

Editing surfaces

Three views over the same source XML. Switching views never loses edits — the source is the single source of truth.

Source

• XML syntax highlighting (tag, attribute, string, comment, CDATA).
• Live DTD / RNG / XSD validation with inline error markers.
• Click-to-fix popups for common errors.
• Ctrl+click any ref-shaped attribute (@href, @keyref, @conref) to jump to the target.
• Auto-close XML tags as you type — and type </ to complete the nearest open element.
• Optional auto-indent: re-format the XML structure as you type or on save, and tidy a file the moment it opens.
• Targeted spell-checking that stays out of markup, links, and proper names, with a personal custom dictionary you can add words to.
• Path fields complete as you type — in the cross-reference, content-reference, image, and publish-target dialogs, and when editing @href / @conref in the Properties pane — directories first, suggestions filtered to what the field accepts.

Visual

• WYSIWYG-style edit surface built in native JavaFX — no embedded browser.
• Tag chips above every block: always visible for structural containers, hover-visible for prose leaves.
• Reorder blocks in place: up / down arrows on a block's chip row swap it with the neighbouring sibling of the same type — a step over a step, a list item over a list item — shown only when the move is possible, with matching keyboard shortcuts. Each move is a single undo step.
• Inline attribute panel: click a chip to see required attributes always present, optional ones as fields — with a calendar picker for date-valued attributes.
• Table editing for CALS, simpletable, task choice tables, and reference properties tables: keyboard navigation between cells, editable titles, column widths, alignment, and row / column insert & delete — click any empty cell to start typing.
• Image editing: alt, href, scope, placement, width, and height as hover-revealed compact fields.
• Equations: author math in LaTeX with a live preview — stored as standard MathML (DITA 1.3 equation domain) with the original LaTeX kept for lossless re-editing, and rendered here, in Preview, and in PDF. Double-click an equation to edit it.
• DITAVAL row marking: excluded rows dim and strike through but stay editable.
• Inline markup toolbar: Bold / Italic / Term / Codeph wrap or unwrap the selection.
• Links stay editable: a plain click selects a link for editing; Ctrl+click follows it.

Preview

• HTML rendering of the source by the in-process renderer, styled to match published output.
• Broad element coverage: CALS / choice / properties tables, footnotes, glossaries, related-links, hazard statements, MathML, and programming-domain markup — across the concept, task, reference, glossary, and troubleshooting specialisations.
• Syntax highlighting inside codeblock.
• DITAVAL filtering applied in real time.
• View as a particular audience: pick an @audience from the toolbar to see the document just as that reader would.
• Links follow on Ctrl+click; a plain click never navigates you away from what you're editing.

Git

• Inline status badges on every file in the project tree.
• Unified diff view that updates as you edit, not only after save.
• Commit, branch, push, pull, and stash from the editor.
• Per-file history and blame.

Refactoring

• Rename topic IDs across the whole project, updating every conref and xref.
• Rename a topic's file and its root id together — from the project tree or straight from the caret — with references to both updated in one pass.
• Safe delete: deleting a file or folder first lists every reference that would break, offers to remove the referencing elements (topicref, xref, …) in the same transaction, and is fully undoable.
• Extract to Sub-Map and Inline Sub-Map: lift a topicref subtree into its own sub-map — in any directory, links rebased — or pull a sub-map back into its host. The pair round-trips losslessly.
• Normalize Naming: convert a project's existing filenames and ids between kebab-case and snake_case, with every reference rewritten.
• Assign project-wide IDs in bulk.
• Set created and modified dates from each file's timestamps across the project, adding the prolog and critdates where they're missing.
• Reference graph: see what links to what.
• Every refactoring is previewed before it touches disk; refactoring history with one-click undo.

Publishing

Ditaro publishes through DITA-OT — and makes the toolkit visible instead of hiding it. Sensible defaults for the common case, with the full machinery one click away when you need it.

• One-click output. HTML5, PDF, and DOCX from any topic or map, with opinionated, readable defaults and no pipeline to configure. The DOCX plugin installs itself on first use.
• Built-in Ditaro targets. Ditaro PDF, HTML, and DOCX are always in the target picker — no project file needed. Each publishes the current document with the opinionated formatting guaranteed, and doubles as an editable template you can save your own tuned copy from.
• Readable PDF, out of the box. Ditaro ships DITA-OT customisations so PDFs look modern with no setup: oversized images scale to fit the page instead of overflowing and clipping, code and terminal blocks get real boxes, notes get a coloured rail, the body is set in embedded Atkinson Hyperlegible, and pages flow single-sided — no blank versos padding out the document.
• Fetch DITA-OT in a click. Download the latest release from inside the app — no manual install — or point at one you already have.
• Your install, discovered. The output formats offered are read from your DITA-OT — core transtypes plus any added by installed plugins — not a frozen, hardcoded list.
• Build parameters, in their own editor. Defining a publish target is a surface of its own: the parameters the chosen transtype accepts are laid out for editing — the ones you've set in bold at the top, the rest alphabetical below, with a name filter and type-aware editors (menus, file pickers, text) showing each default as a hint.
• Problems pane. Errors and warnings are parsed out of DITA-OT's log into a clickable list — double-click a located message to jump straight to the offending source line.
• Project Health tab. Publish → Audit Project sweeps the whole project — broken references, duplicate ids, unused keys, unused topics, missing alt text — into a docked tab. It stays live: findings refresh as you save, refactor, or edit files outside the app, and double-click opens the file at the exact line.
• Writing tab. Publish → Check Writing measures your prose against the Unified Writing Standard — sentence and paragraph length, contractions, serial commas, bare bold / italic inside steps, note types and safety-note placement, missing or overlong shortdescs, title capitalisation. Rules are scoped by context, so a step is judged as a procedure and a paragraph as description. Findings underline in the source editor as you type and list for the whole project in a docked tab, with a severity filter and double-click-to-open.
• The ruleset is yours to set. Every rule the checker knows is listed and grouped by the standard's sections, each with a checkbox and a severity of your choosing — beside the findings in the Writing tab, where a toggle re-checks straight away, and again in Preferences. Nothing is hidden in a config file you have to hand-edit.
• Installed plugins, visible. Publish → DITA-OT Plugins lists every plugin in your toolkit with its id, version, and the transtypes it contributes.
• Named publish targets. Publish → Publish Targets reads the deliverables from a standard DITA-OT project file and makes each one-click publishable, with New / Edit / Delete to manage them. Each is a standard DITA-OT <deliverable> any toolchain can run, never a proprietary Ditaro file.

Built-in documentation

• Help → User Guide opens Ditaro's own guide as a live DITA project — read it in Preview, fully offline.
• The guide is authored in DITA and ships inside the app, so it can never drift from the build.
• It doubles as a worked example: keys resolving, content reuse, and conditional flags all rendering in the real editor.