File Formats
Every format Alekhya reads and writes — projects, shots, brush packages, fonts and rendered output — and how files are identified.
Reference
- Menu
- File ▸ Import · File ▸ Export
Alekhya reads and writes two document formats of its own, imports brushes and fonts, and renders out to five image and video formats. This page lists all of them, states exactly what travels inside each, and documents the two behaviours that most often surprise a reader: files are identified by their contents, not their extension, and opening a shot asks which project it should join.
Everything at a glance
| Extension | Type identifier | Read | Written |
|---|---|---|---|
.alekhya | com.alekhya.project | Yes | Yes |
.alekhyashot | com.alekhya.shot | Yes | Yes |
| Brush package (JSON) | none | Yes | Yes |
.abr | none | Yes | No |
.ttf, .otf | public.truetype-ttf-font, public.opentype-font | Yes | No |
.png, .jpg | system | No | Yes — rendered output |
.mp4, .mov | system | No | Yes — rendered output |
.alekhya and .alekhyashot are the only two type identifiers Alekhya declares. Both
are exported types conforming to public.data and public.content, described as "Alekhya
Project" and "Alekhya Shot", and both are registered with Alekhya as their owner and
editor.
Opening either from Files or AirDrop hands Alekhya a copy. Alekhya does not open documents in place, so an import never edits the file you were sent — it becomes a new project on this device, and the original is left alone.
Projects — .alekhya
A .alekhya file is a whole project: every shot, the edit timeline, and every external
asset any of them reference.
What travels inside:
| Contents | Notes |
|---|---|
| The manifest | The project's name and metadata. Read on its own, without unpacking a single asset. |
| The project folder, wholesale | Every shot document and sidecar, copied entire. |
| Brush assets | Tips, textures, motifs and meshes, gathered by scanning the strokes — not the brush library. An export therefore carries the imagery for a brush you deleted months ago. |
| Particle graphics | Including graphics referenced only by nested sub-emitters. |
| Imported fonts | Only fonts you imported, and only the families a text object actually uses. Bundled and system families are not carried — they are already on the other device. |
| Video and volume media | Files under Documents but outside the project folder travel too. |
Assets are stored in sorted order, so re-exporting an unchanged project produces a byte-identical file. Each section is compressed only when compression actually shrinks it — JSON collapses; an embedded MP4 or PNG is stored verbatim rather than being re-compressed for nothing.
Missing assets are skipped rather than failing the export: a shot that already lost a tip still exports. A failed import cleans up after itself, removing the half-written project rather than leaving a broken row on the Home screen.
Video paths are rebased on import
A video layer stores a path that embeds the project's identity. An imported project is a new project with a new identity, so those paths are rewritten as it is unpacked. Without this, every clip in an imported project would load black. Volume sidecars carry the same kind of path and are rebased with them.
Shots — .alekhyashot
A .alekhyashot is a single shot, and it can be imported into any project — including
one on another device that has never seen the project it came from.
| Contents | Notes |
|---|---|
| The manifest | The shot's name and metadata. |
| The shot document | The layers, strokes, cels, keyframes and settings. |
| Media | Video and volume files, keyed by layer identity rather than filename, so two layers holding same-named files cannot collide. |
| Assets | Brush assets, particle graphics and imported fonts, as for a project. |
A shot never carries an edit timeline. The edit belongs to a project, not to a shot.
Because a shot's media paths point into the project that owned it — which the receiving device may not have — an imported shot re-homes its media: each file is written into the target project's own media folder under a fresh name, and the layer is repointed at it. If a media file is missing from the archive, the layer is dropped rather than left holding a path, which could otherwise resolve to some unrelated file on this device.
Opening a shot asks which project it joins
A shot has no home of its own. Open a .alekhyashot — from Files, from AirDrop, or with
Import Shot… — and Alekhya asks where to put it.
Creates a project named after the shot and imports the shot into it. This is the only option offered when you have no projects yet.
Every project already on the device, each showing its shot count. Tap one to import the shot into it. Shown only when at least one project exists.
Dismisses without importing.
The name in the prompt is read from the archive's manifest alone — no asset is unpacked to show it, so the prompt appears immediately even for a very large file. If the manifest cannot supply a name, the filename is used.
The Shots tab imports shots only. Hand it a whole project and it says so: "That's a whole Alekhya project, not a single shot. Import it from the Home screen."
Files are identified by reading them, not by their extension
Nothing in Alekhya trusts a file extension. An incoming file is identified by decoding its container and inspecting the manifest inside.
This is not fastidiousness. AirDrop, cloud drives and messaging apps strip extensions in
transit, and a file that arrives named Shot 2 with no extension has to be openable anyway.
For the same reason, the file pickers deliberately accept any data file alongside the
two declared types — an extensionless Alekhya file is still selectable.
Project and shot files share one container and one magic number; they are told apart by what the manifest requires. A project manifest must carry a project; a shot manifest must carry a shot. Neither can be mistaken for the other, so routing is unambiguous.
The checks run in order: the container's magic, its version, the manifest's integrity, then the format version. Older files open; files from a newer build refuse with an update prompt.
| What you may see | Meaning |
|---|---|
| "This isn't a readable Alekhya file (…)." | The container or its manifest could not be decoded. |
| "This file was saved by a newer version of Alekhya (format N). Update the app to open it." | The file is from a later build than this one. |
| "The file contains an unsafe file path (…) and was not imported." | An archive entry named a path outside where it belongs. Nothing was written. |
| "That project no longer exists." / "That shot no longer exists." | The document was deleted between the action and its execution. |
Paths inside an archive are validated before a single byte is written, and unknown section prefixes are rejected rather than ignored.
Exporting projects and shots
Export a project from the Home screen, and a shot from the Shots tab — both from the swipe actions and the context menu. Alekhya packages the file and hands it to the share sheet, so it can go to Files, AirDrop, Messages or anywhere else rather than only to disk.
Imported names are de-duplicated rather than overwriting: importing a second "My Film" gives you "My Film 2".
A shot exports its last saved state
Exporting a shot reads it from disk. If the shot is open on the canvas with unsaved changes, those changes are not in the exported file. Save the shot first — File ▸ Save Shot, or the save button on the command bar, which is highlighted while there is anything to save.
Brush files
One import action reads every brush format. Alekhya sniffs the bytes: it tries its own
brush package first, and falls through to a Photoshop .abr pack if that fails. You do not
choose a format, and the extension is not consulted.
Alekhya brush packages
A brush package is plain JSON holding the brush and its assets — the tip image and any textures, motifs or meshes it references, carried inside the file. Asset identity is derived from the asset's own contents, so importing a package restores its imagery under exactly the identity it had when exported, and a package whose assets are already on the device does not duplicate them.
Exporting a brush writes a JSON file named after the brush preset. The in-app hint calls
these .alekhyabrush files; the exported file carries the .json extension. This makes no
practical difference, because import identifies the file by reading it.
Photoshop .abr brush packs
Alekhya reads Photoshop .abr brush packs. What imports is the tip shape, its name, and
its spacing — and nothing else. The preset behind the brush is deliberately not
translated: the dynamics, the scattering and the rest are Alekhya's to set. An imported tip
arrives as a brush in your library that you then tune in
Brush Settings.
| Fact | Detail |
|---|---|
| Versions read | Photoshop 6 and 10 format records. Older files are refused: "That's a Photoshop N brush file, which is too old to read. Re-save it from a recent Photoshop and try again." |
| Spacing | Converted from Photoshop's percentage of diameter to Alekhya's fraction. |
| Size | Taken from the tip image's larger dimension. |
| Limit | Up to 200 brushes per pack. Beyond that: "Imported N of M into “category”. The rest were skipped — that's a lot of brushes." |
| Category | The pack's filename, or Imported if it has none. |
A pack whose brushes are all built from Photoshop's own built-in round tip contains no tip images to read, and reports so: "That Photoshop pack has no brush shapes in it — its brushes are built from Photoshop's own round tip, which doesn't transfer."
Photoshop .abr is the only brush pack format Alekhya reads besides its own. No other
application's brush or brush-set format is supported.
Fonts
Alekhya imports .ttf and .otf fonts from the Import button in the font picker
(Text). The file is copied verbatim, registered with the system, and
joins the font list immediately.
Imported fonts travel inside a .alekhya or .alekhyashot archive — but only the ones a
text object actually uses. Bundled and system families are not carried.
Rendered output
File ▸ Export renders the shot. The three menu items seed the format; the export panel offers all five.
| Format | Extension | Transparency |
|---|---|---|
| PNG Image | .png | Yes |
| JPEG Image | .jpg | No |
| Video (MP4) | .mp4 | No |
| Video (MOV · HEVC) | .mov | No |
| PNG Sequence | .png | Yes |
Which of the five above to render. Seeded from the menu item you chose.
A resolution preset. The shot's own resolution is always selectable, even when it is a custom size that matches no preset.
½×, 1× or 2× of the chosen resolution. The resulting pixel size is shown beside the picker.
Full Timeline, Work Range or Current Frame. Shown only for movies and image sequences; a still is always one frame.
Shown only for movies and image sequences. Seeded from the shot's own frame rate.
Shown only for JPEG Image.
Shown only for PNG Image and PNG Sequence — the two formats that carry an alpha channel.
Two limits apply to the rendered pixel size regardless of the settings above. The longest side is capped at 4096 pixels, with both dimensions scaled to fit — 4K at 2× renders at 4096 × 2304, not 7680 × 4320. Both dimensions are then rounded down to an even number, which the video encoders require.
The rendered file is named after the shot and delivered through the share sheet.