Installation

Velitask for Windows is installed from an MSI installer (recommended) or run from a ZIP archive without installation.

Why This Matters

Velitask is a desktop app for Windows. The distributions are bundled with a Java Runtime (JRE 21), so you do not need to install Java separately. Two formats are enough to cover the main scenarios: a system installation with shortcuts through MSI, and a "portable" launch from a flash drive or any folder through ZIP.

System Requirements

For editing and exporting video, a fast disk (NVMe) and enough RAM are useful — Velitask keeps playback frames and sensor caches in memory.

Installing From MSI (Recommended)

1. Download Velitask-X.Y.Z.msi from the downloads page at velitask.com.
2. Run the MSI by double-clicking it. The installer will ask for administrator privileges.
3. Choose the installation folder (default: C:\Program Files\Velitask\) and click Install.
4. After it finishes, a Velitask shortcut appears in the Start menu, and an uninstall entry appears in Add or Remove Programs.

Running From a ZIP Archive (Portable Mode)

1. Download Velitask-X.Y.Z.zip from the downloads page.
2. Extract the archive to any folder (a path without spaces or Cyrillic characters is more reliable).
3. Open the extracted folder and run VelitaskApp.exe.

In this mode Velitask's service data (logs, plugins, templates in %USERPROFILE%\.velitask\) and settings (in the system registry) are created outside the ZIP folder — the extracted folder itself stays clean.

Where Velitask Stores Its Data

The .velitask folder in your profile is created on first launch. It holds logs\, plugins\ and templates\. Deleting this folder clears logs, plugins and user templates but does not reset the application settings — theme, language, the recent-projects list and panel layout are stored separately (in the system registry). Your projects are not affected.

The OSM tile cache is by default stored inside the project folder (<project>\.cache\OSM\). In the project settings you can switch storage to the shared application folder or to an arbitrary external path.

Uninstalling

• MSI installation: Settings → Apps → Velitask → Uninstall (or Programs and Features).
• ZIP launch: simply delete the extracted folder.
• To erase user data (logs, plugins, templates), delete %USERPROFILE%\.velitask\. This does not reset the application settings (theme, language, recent projects, panel layout): they live in the system registry, not in .velitask. A full reset of settings to their defaults is done separately — by the reset-settings function inside the application.

Related Sections

• Interface Overview — what you see on first launch.
• Your First Project — a step-by-step path from empty project to export.
• Troubleshooting — if something does not launch or works slowly.

Troubleshooting

• Double-clicking VelitaskApp.exe does nothing. Make sure you extracted the ZIP completely and are not running it directly from the archive. Windows may also block the launch; in the file properties, check Unblock.
• The MSI installation requires administrator privileges and they are unavailable. Use the ZIP package — it does not require installation.
• Antivirus reports the installer. Velitask is not signed with a corporate certificate. Add the application folder to your antivirus exclusions.
• It does not launch on Windows 7/8. These are not supported. The minimum is Windows 10 64-bit.

Interface Overview

The main Velitask window is divided into the menu, side tool panels, the central tabbed area (where the Mixel player opens), and the status bar at the bottom. This is enough to open a project, add a source, build a composition, and export the result.

Why This Matters

Velitask brings many different activities into one window: adding video and tracks, placing indicators, synchronizing time, viewing sensor tables, exporting. To stay oriented, it is important to understand right away where things are and in what order to return to them.

Main Menu

Side Panels (Tool Tabs)

Along the sides of the central area are switchable panels. By default some open on the left, some on the right. Any panel can be closed with the cross and brought back through the View menu, and can also be dragged to the other side: right-click the tab → Move left / Move right (or Close).

• Project — the project tree: video, GPX tracks, images, OSM, sensors.
• Layers — the list of layers in the current Mixel: video, map, charts, indicators.
• Indicators — the catalog of installed indicators (plugins) that can be placed into a Mixel.
• Devices — the list of Device Profiles with time zone and clock offset settings.
• Time — synchronization: which time a given frame corresponds to.
• Tasks — the queue of background operations: source scanning, preview generation, export. Progress and errors are shown here.
• Properties — parameters of the selected object (layer, indicator, source).

Center Area: Tabs and the Mixel Player

In the center of the window is a tabbed area where project documents open. An open Mixel is shown as a composition player with the usual controls:

• Start, Previous frame, Play / Pause, Next frame, End buttons.
• A timeline slider with the current-position cursor and date and time fields for precise jumps.
• A preview of the video and overlaid indicators at the current moment.
• A monitoring volume slider (it affects only playback in the editor, not the export).

What the player shows is what you will see in the final exported video.

Status Bar

At the bottom of the window is a thin strip with the status. When nothing is running it shows "Ready". During a background operation its name is shown, and when there is a second task — the progress percentage as well; a progress indicator appears next to it. On the right is the network state indicator ("Offline").

Startup Window

On first launch a welcome window appears with a "Get started!" button and a "Show this on startup" checkbox. Clear the checkbox if you want to go straight to the working window; you can bring the welcome screen back through Help → Show welcome message.

What to Do Next

1. Create a project — File → New Project... (Ctrl+N) and choose a folder.
2. Add a source: copy a video or a GPX track into the project folder — it will be picked up by the auto-scan within a few seconds.
3. Configure the Device Profile so frames and tracks match in time.
4. Open the Mixel and add the indicators you need.
5. Export the video.

The detailed scenario is in Your First Project.

Related Sections

• Installation — if you have not launched Velitask yet.
• Your First Project — a practical step-by-step walkthrough.
• Mixel and Layers — what the central player is.
• Sources Panel — details about the tree on the left.

Your First Project

A 15-minute scenario: new project → add video and a GPX track → synchronize time → place a couple of indicators into the Mixel → export video.

Why This Matters

So you can quickly see the "full cycle" of Velitask. All the steps below work on a single pair: "action-camera video + a GPX track from the same ride" — this is the most common scenario.

You will need:

• one video (for example, an MP4 from a GoPro);
• one GPX track recorded at roughly the same time (from a bike computer, watch, or smartphone);
• an empty folder where Velitask will create the project file .vtproj and look for sources.

Steps

1. Create a Project

1. Open Velitask.
2. File → New Project...
3. In the dialog, enter the project name (for example, my-first-trip) and the project folder (for example, D:\Velitask\). Velitask will create a <name>.vtproj file (the project database) in the chosen folder — for example, my-first-trip.vtproj.
4. The folder where the .vtproj file lives is the project folder: it is exactly the one Velitask scans looking for sources.

After creation, you will see an empty Mixel in the center and an empty source tree on the left.

2. Add Video

1. Copy a .mp4 (or .mov) file into the project folder — where the .vtproj file lives (a subfolder is fine).
2. Velitask periodically scans the project folder and picks up the new file by itself: a my-clip.mp4 node appears in the source tree, and the metadata (duration, resolution, fps, shooting date) is read automatically.
3. The frame analysis progress appears in background tasks (the Tasks tab).

3. Add a GPX Track

1. Copy a .gpx file into the project folder. Velitask recognizes GPX by its extension during scanning.
2. A my-track.gpx node appears in the tree. Inside it are sensor sets: Geo (coordinates), Distance (distance from start), Elevation (altitude), Speed, Slope — depending on what is present in the source file.
3. On the Tasks tab you will see the import. Wait until it finishes — for large GPX files it takes noticeable time.

4. Check Video and Track Time

Video and GPX almost never "match" by themselves: the camera may be set to another time zone, GPX may be in UTC, and so on. This is handled through the Device Profile.

1. Open the Devices tab.
2. Velitask automatically creates Device Profiles: at least one default profile per source type (video, GPX, etc.), and if a specific device (camera brand/model) can be recognized from the metadata, a separate profile is created and bound to the source. Open the camera profile:
   • Time zone — set the one the camera clock was using (for example, Europe/Moscow).
   • Offset, sec. — leave 0 if the clock was accurate. If it was wrong (the camera was a minute fast), enter the offset here.
3. Do the same for the GPX source profile. On most GPS devices the track is already in UTC: keep the time zone as UTC and the offset as 0.

See Time Synchronization for details.

5. Place Indicators Into the Mixel

1. The Indicators tab shows the list of available indicators: speedometer, distance text, time text, map, slope text, and so on.
2. Drag the indicator you need onto the player canvas in the center. For example, Speedometer.
3. The right panel shows the layer properties: position, size, source binding. Link the indicator to the GPX speed sensor.
4. In the same way, add Time text (clock) and Map (mini map) — a typical set for a cycling ride.

See Mixel Editor for details.

6. Preview the Result

1. Click Play (▶) — Velitask plays the video with the overlaid indicators.
2. Scrub the timeline cursor and check that the speed/distance/time values match the video.
3. If something does not line up, return to step 4 and refine the Device Profile.

7. Export Video

1. File → Export → Video → Video....
2. Choose the range (the entire Mixel by default), the quality preset, codec (H.264 is the most compatible), fps, audio.
3. Specify the output file path (for example, D:\Velitask\my-first-trip\export.mp4).
4. Start the export. Progress is shown on the Tasks tab.
5. When finished, the ready file appears in the specified folder.

See Video Export for details.

What to Try Next

• Add more videos to one project and build a sequence from them.
• Add additional sensors (cadence, power) — Velitask reads them from GPX if they are present.
• Tweak the indicator settings: size, color, position.
• Save an export preset to quickly apply the same encoding settings to future projects.

Related Sections

• Interface Overview
• Time Model
• Importing Video Files
• Importing GPX
• Time Synchronization
• Mixel Editor
• Video Export

Time Model

The raw time stays with the source — exactly as the device recorded it. Velitask computes the single UTC time on the fly through the Device Profile — the pair "time zone + clock offset" — and never stores it separately (neither in the database nor in state).

Why This Matters

Video, GPX tracks, and sensor records carry different time on their own. One camera has its clock set to Europe/Moscow, another device runs in UTC, a third clock is one minute fast, while a GPX receiver always writes UTC. If you simply combine everything as is, speed and distance values will appear at the wrong moment.

Velitask solves this as follows:

1. All original raw timestamps (raw) are stored as is — what the device recorded.
2. Through the Device Profile they are converted to UTC when accessed (UTC is not stored, it is computed on demand).
3. The entire internal project scale works in UTC — the Mixel timeline, indicators, and export.

The user never enters UTC manually anywhere — you only say "this camera uses this time zone and is fast by this many seconds".

Device Profile

A Device Profile is a project record that links a source to the rules for interpreting its time.

Velitask does not create a separate Profile for each source. On import it creates one default Profile per source type (linked to the project root), and based on hints from the file metadata it may additionally create a profile for a specific device and link it directly to the source. Profiles are listed on the Devices tab and edited there.

Profile Inheritance

To avoid setting a Profile on every source separately, inheritance works along the chain source → parent folders → root:

1. If a Profile is linked directly to the source, it is used (priority 1).
2. If not, we go up through the parent folders and take the first Profile found.
3. If there is none there either, the Profile linked to the project root is used.
4. If nothing is linked anywhere, the system UTC Profile with offset 0 is used.

So it is convenient to configure a "GoPro Profile" once at the project root and not return to it for every clip.

How Time Zone and Offset Become UTC

The formula is simple:

UTC = raw − tz_offset(raw) + offset

• raw — what the device recorded.
• tz_offset(raw) — the time zone offset from UTC at that moment (accounting for daylight-saving time).
• offset — the user clock correction ("Clock offset"); entered in seconds, stored internally in milliseconds.

Velitask works both ways: it can write UTC and show the device's local time — for example, in the clock indicator.

What Is Important to Understand

• A one-hour difference is a "forgotten" time zone. If indicators are shifted by exactly one hour, the issue is usually not the offset but an incorrect Profile tz.
• A few seconds of difference is the clock offset. Cameras are usually off by 5–60 seconds relative to a reference. These seconds are set through the Profile offset: if the clock is fast, enter a negative value; if it is slow, a positive one.
• GPX is almost always in UTC. If the GPX file explicitly states UTC (the typical case), UTC and a zero offset are enough for the Profile.

Related Sections

• Time Synchronization — how to actually compare and adjust time in the UI.
• Importing GPX — what Velitask does with GPX time during import.
• Troubleshooting — the section about shifted indicators.

Mixel and Layers

Mixel is the main composition format in Velitask: a rectangular canvas with a set of layers, each showing its own content (video, map, indicator, shape). It is both what you see in the player and what ultimately goes into export.

Why This Matters

A typical telemetry video needs to show several things at once: the camera video itself, current speed and distance values, a mini map with the track, and maybe a slope chart. All of these are layers of one composition. A Mixel is the container that stores and plays them.

A Mixel is created and stored separately for each open source: when you open a video or a track, Velitask brings up (or builds from a template) its own composition and saves it next to the source in the project. A project has no single "shared" Mixel — each source has its own.

What a Mixel Consists Of

Layers are ordered: the layer higher in the list is closer to the viewer and drawn above the others.

Layer Types

Out of the box, Velitask can create these layers:

Data layers (except Video, Image, shapes, and Group) are indicators of the built-in Velitask plugin "out of the box" (VelitaskPlagin.defineIndicators); see Indicators and Plugins. The list of layers is extensible: installing a new plugin adds new types to the Mixel.

Binding a Layer to a Source

Data layers (Speedometer, Distance, GeoMap, …) show values from a specific sensor of a specific source. This binding is stored in the layer properties:

• The layer properties in the right panel include a "Source" field (or several fields if the indicator uses multiple channels — these are the SensorProperty / SourceProperty properties).
• When a layer is added, compiled, or a template is applied, Velitask auto-picks a suitable source: the indicator scans the project sources, selects those compatible with the required sensor, and sets the best one according to its strategy (applyDefaultSource). If the auto-pick was wrong, you reassign the source manually in the same field.
• If there is no suitable source or the field is cleared, the layer shows empty content or "—".

Layers and Time

All layers live on one shared scale — the Mixel timeline in UTC. At any moment on the timeline, Velitask:

1. Takes the current UTC time of the cursor.
2. Gives each layer the value of its sensor at that moment.
3. Draws the resulting image — this is the Mixel frame.

The scale is shared, so camera video and GPX values are automatically synchronized (if Device Profiles are configured correctly).

Mixel as JSON and Template

A Mixel can be saved not only inside a project, but also as a separate .vttp template. This file stores a JSON composition: layers, order, placement, and indicator properties.

A template is useful when you want to reuse one layout in different projects: for example, always open video with a video layer, speedometer, and map, and open a GPX track with a full-canvas map.

Velitask can apply such templates manually and automatically:

• manually — through Tools → Apply Template...;
• export the current composition — through File → Export → Template...;
• automatically — when a new source has no saved Mixel yet;
• separately for thumbnails — through thumbnail-video.vttp, thumbnail-gpx.vttp, and thumbnail-image.vttp.

Details: Mixel JSON and Templates. On layer placement in a template specifically: Mixel Layouts in JSON.

Related Sections

• Interface Overview — where the Mixel player is located.
• Mixel Editor — practical layer adding and configuration.
• Indicators and Plugins — what an indicator is as a layer type.
• Time Model — why everything lines up in time.
• Mixel JSON and Templates — how to save and apply .vttp.
• Mixel Layouts in JSON — how to control layer placement in a template.

Mixel JSON and Templates

In short: a Mixel can be saved as a .vttp template, placed in a project folder or the user templates folder, and applied to new sources. Inside .vttp is JSON that describes layers, placement, and properties.

Why This Matters

Usually it is easier to build a Mixel with the mouse: add video, map, speedometer, text, and configure them in the properties panel. But sometimes a template is useful:

• you often build the same layout for different rides;
• you want to keep a good composition as a separate file;
• you prepare several projects with the same colors, sizes, and positions;
• you want to quickly change basic values in the JSON text;
• you build a template once and apply it to new videos or GPX tracks.

JSON is an advanced workflow. If you do not want to edit files manually, you can simply configure the Mixel in the interface and export it as a template.

How to Use It

Create a Template From the Current Mixel

1. Open a source with an already configured Mixel.
2. Check the layers, order, sizes, colors, and data bindings.
3. Choose File → Export → Template...
4. Save the file with the .vttp extension.
5. Put the file into the project folder or the user templates folder.

Default user templates folder:

%USERPROFILE%\.velitask\templates

You can change it in Tools → Settings... → Templates (the "Mixel templates" section).

Apply a Template Manually

1. Open the source or Mixel where you want to apply the template.
2. Choose Tools → Apply Template...
3. Select Base template or a specific .vttp from the project.
4. Check the layer list and data bindings.
5. Save the project if the result is correct.

Applying a template replaces the current Mixel composition. Before experimenting, it is better to save the project or export the current Mixel to a separate .vttp.

Data bindings are not stored in the template as concrete ids. When a template is applied, Velitask picks sources and sensors for the current source itself: the source layer is filled with the current source, and the sensor properties of indicators are picked automatically. So you do not need to copy sourceId, sensorId, and similar ids from someone else's project by hand — in the new project they may point to different data or not exist at all.

What .vttp Is

.vttp is a Mixel template file. Inside it is a JSON composition:

• layer list;
• layer order;
• placement of each layer;
• indicator properties;
• settings that help Velitask apply the layer to a new source.

A regular Mixel is stored inside the project. .vttp is a separate file used for reuse.

Where Velitask Looks for Templates

When a source has no saved Mixel yet, Velitask tries to choose a default template automatically.

First the application builds candidate file names:

For each name, levels are checked:

The priority is:

1. More specific names first: ride.vttp outranks mp4.vttp, and mp4.vttp outranks video.vttp.
2. Within one name, the project template outranks the user template.
3. The user template outranks the system template.
4. File name case does not matter: Video.vttp and video.vttp are treated as the same option.

The user and system folders for default templates are checked only at their top level. If you put video.vttp into a nested subfolder of the user templates folder, automatic search will not see it.

Project, User, and System Templates

A project template is convenient when one project should have its own style. For example, put video.vttp into the project folder, and new videos in that project will get this layout if they do not already have a saved Mixel.

A user template is convenient for a personal style. For example, put gpx.vttp into %USERPROFILE%\.velitask\templates, and new GPX tracks in different projects will start with your map or indicator set.

System templates are shipped with Velitask. It is better not to edit them directly: copy the needed .vttp into the user folder and edit the copy.

Thumbnail Templates

Thumbnail templates are used for thumbnails and previews in the interface. They do not replace the main source Mixel.

Currently these names are used:

Thumbnail templates are searched only in the user and system templates folders. The project hierarchy is not used for them.

How Mixel JSON Is Structured

The top level usually contains a layers list. Each item in the list is one layer on the canvas.

Example built-in video template:

{
  "layers": [
    {
      "name": "com.velitask.plagin.official.video",
      "data": {
        "maket": { "preset": "fill" }
      }
    },
    {
      "name": "com.velitask.plagin.official.speedometer",
      "data": {
        "maket": { "preset": "auto" }
      }
    },
    {
      "name": "com.velitask.plagin.official.geoMap",
      "data": {
        "maket": { "preset": "auto" }
      }
    }
  ]
}

What matters here:

• layers — layer order;
• name — technical layer or indicator name;
• data — settings of this layer;
• maket — layer placement on the canvas;
• preset: fill — the layer fills the available area;
• preset: auto — Velitask chooses a suitable place automatically.

For details about maket, its types, and fields: Mixel Layouts in JSON.

Example GPX map template:

{
  "layers": [
    {
      "name": "com.velitask.plagin.official.geoMap",
      "data": {
        "maket": { "preset": "fill" },
        "properties": {
          "fitTrack": { "value": true }
        }
      }
    }
  ]
}

Here properties contains the properties of a specific indicator. In the example, fitTrack enables fitting the map to the track.

What Is Safe to Edit Manually

The safest changes:

• change the placement preset if you understand the difference between fill and auto;
• change simple properties with a clear value, such as true / false, a number, or a color;
• remove an unnecessary layer from the layers list;
• change the order of layers in the list;
• copy a ready layer from another template if the needed indicator is installed in Velitask.

After each change, test the template in a copy of the project. It is better to change one small piece at a time.

What Is Better Left Alone

Be careful with these fields:

• name — if such an indicator is not in your installation, the layer will not appear;
• source and sensor bindings if they are present in the template;
• unknown nested fields inside properties;
• JSON exported by a newer Velitask version if you open it in an older version of the app.

Do not blindly copy sourceId, sensorId, and similar ids from one project to another. In the new project, those ids may mean different data or not exist.

Checking a Template

1. Make a copy of the project or use a test project.
2. Put .vttp into the project folder or the user templates folder.
3. Open a source for which Velitask has no saved Mixel yet.
4. Check which layers appeared.
5. Check layer properties and source bindings.
6. Scrub through the timeline.
7. Run a short test export or export one frame.

If the template was applied not as expected, temporarily remove the file from the templates folder and open the source again.

Troubleshooting

Related Sections

• Mixel and Layers — the basic Mixel model.
• Mixel Editor — how to build a composition in the interface.
• Mixel Layouts in JSON — how to configure layer placement in .vttp.
• Indicators and Plugins — which indicators can be added as layers.
• Video Export Presets — another preset type, unrelated to .vttp.
• Troubleshooting — general project, import, and export errors.

Mixel Layouts in JSON

In short: maket controls where a layer appears in a Mixel when a .vttp template is applied. In templates, Velitask supports three presets: auto, fill, and proportional.

Why This Matters

A Mixel template should work in more than one project and one resolution. If you save a layer in exact pixels, it may look good at 1920x1080, but shift or become too small in vertical video, a square frame, or 4K.

maket solves this task. It stores not just current coordinates, but a placement rule for the layer:

• fill the parent completely;
• ask the indicator to choose its standard place;
• place the layer as percentages of the parent size.

For manual .vttp editing, proportional is usually the most useful option: it is clear, portable, and handles resolution changes well.

How to Use It

1. Open the .vttp file in a text editor.
2. Find the needed layer inside layers.
3. Inside data, add or edit the maket object.
4. Choose a preset: auto, fill, or proportional.
5. For proportional, set x, y, w, and h.
6. Apply the template in Velitask and check the result.

Example speedometer layer in the top-right corner:

{
  "name": "com.velitask.plagin.official.speedometer",
  "data": {
    "maket": {
      "preset": "proportional",
      "x": 0.73,
      "y": 0.05,
      "w": 0.22,
      "h": 0.30
    }
  }
}

On a 1920x1080 canvas this gives approximately:

Where maket Is Stored

maket is inside data of a specific layer:

{
  "layers": [
    {
      "name": "com.velitask.plagin.official.video",
      "data": {
        "maket": { "preset": "fill" }
      }
    }
  ]
}

For a top-level layer, the parent is the whole Mixel canvas. For a nested layer, the parent is the layer or group that contains it.

What Happens When a Template Is Applied

When Velitask applies .vttp, it reads the JSON in template mode. For each layer, the order is:

1. If maket exists, Velitask applies it and calculates positionInParent and size.
2. If there is no maket, but size and positionInParent exist, the exact values from the JSON are used.
3. If this is a template and there is neither maket nor exact size and position, auto is applied.

Practical conclusion: in .vttp, it is better to set maket explicitly. The template becomes clearer and more stable.

If one layer contains maket, size, and positionInParent at the same time, maket wins. The exact pixel fields remain in the file, but they are ignored when the layer is loaded.

Layout Types

If preset is missing inside maket, Velitask treats it as auto.

If an unknown preset is given, Velitask cannot apply that maket. If size and positionInParent are next to it, they are used. If this is a template without exact size and position, the layer eventually receives auto.

auto

auto looks like this:

{
  "maket": { "preset": "auto" }
}

auto does not store coordinates, size, anchor, or margins in .vttp. Instead, the layer invokes its own standard placement: inside Velitask, auto runs the layer's applyDefaultParameters(), which computes the layout by the indicator's rules relative to the parent size.

For official indicators, the standard placement is defined in the indicator itself via defineMaket: the indicator specifies alignment (vertical and horizontal) and a base size. The concrete place in pixels is then derived from these rules and the parent size.

Confirmed values of official indicators:

These values serve as a starting layout. The user can later move and resize the layer in the editor.

Note: the code also has a Slope speed indicator (top-right, 400x200), but it is not registered in the official plugin and is unavailable in a normal build, so it is not included in the table above.

Choose auto when:

• you want the indicator's standard placement;
• exact position does not matter to you;
• you are making a very short template, like the built-in video.vttp;
• you trust the indicator to pick a convenient place.

Do not choose auto when:

• you need precise control over the composition;
• several layers must be placed symmetrically;
• the template must look the same across different projects;
• you want a specific percentage of width and height.

Important: .vttp cannot configure the internal margins of auto. In a template you can only select preset: "auto". If you need your own coordinates, use proportional.

fill

fill looks like this:

{
  "maket": { "preset": "fill" }
}

It does one simple thing:

• x = 0;
• y = 0;
• width equals the parent width;
• height equals the parent height.

For a top-level layer, this means the layer takes the entire Mixel canvas. For a layer inside a group, it means the layer takes the entire group.

Good scenarios:

• the main video across the whole Mixel;
• a map across the whole Mixel for a GPX-only project;
• a background rectangle inside a group;
• a thumbnail template where one layer must fill the whole thumbnail.

Example:

{
  "name": "com.velitask.plagin.official.video",
  "data": {
    "maket": { "preset": "fill" }
  }
}

If you want margins around the edges, fill is not suitable. Use proportional, for example x=0.03, y=0.03, w=0.94, h=0.94.

proportional

proportional looks like this:

{
  "maket": {
    "preset": "proportional",
    "x": 0.10,
    "y": 0.20,
    "w": 0.30,
    "h": 0.40
  }
}

The fields mean:

Values are usually set from 0.0 to 1.0.

Velitask does not strictly clamp these numbers. Negative values or values above 1.0 can move a layer outside the parent. Sometimes this is useful for a deliberate edge bleed, but more often it is a mistake.

If fields are omitted, default values are applied:

So this JSON:

{
  "maket": { "preset": "proportional" }
}

is equivalent to a layer filling the whole parent:

{
  "maket": {
    "preset": "proportional",
    "x": 0.0,
    "y": 0.0,
    "w": 1.0,
    "h": 1.0
  }
}

For full fill, fill is still better: the template is shorter and clearer.

Ready-Made Formulas

Top-Right Corner

The layer takes 22% width, 30% height, with a 5% top margin and 5% right margin:

{
  "maket": {
    "preset": "proportional",
    "x": 0.73,
    "y": 0.05,
    "w": 0.22,
    "h": 0.30
  }
}

Why x = 0.73: 1.0 - 0.05 - 0.22 = 0.73.

Bottom-Left Corner

The layer takes 34% width, 32% height, with a 4% left margin and 5% bottom margin:

{
  "maket": {
    "preset": "proportional",
    "x": 0.04,
    "y": 0.63,
    "w": 0.34,
    "h": 0.32
  }
}

Why y = 0.63: 1.0 - 0.05 - 0.32 = 0.63.

Center

The layer takes 40% width and 25% height and is centered:

{
  "maket": {
    "preset": "proportional",
    "x": 0.30,
    "y": 0.375,
    "w": 0.40,
    "h": 0.25
  }
}

Formulas:

• x = (1.0 - w) / 2;
• y = (1.0 - h) / 2.

Bottom Bar Across the Width

{
  "maket": {
    "preset": "proportional",
    "x": 0.0,
    "y": 0.88,
    "w": 1.0,
    "h": 0.12
  }
}

This is convenient for a bottom information panel.

Map With Margins

{
  "maket": {
    "preset": "proportional",
    "x": 0.03,
    "y": 0.56,
    "w": 0.34,
    "h": 0.39
  }
}

Good for a map in the bottom-left corner with a small edge margin.

Slight Bleed Outside the Edge

{
  "maket": {
    "preset": "proportional",
    "x": -0.02,
    "y": -0.02,
    "w": 1.04,
    "h": 1.04
  }
}

This can slightly enlarge a background or map to avoid a thin empty edge strip. Use carefully: part of the layer will be outside the canvas.

maket, size, and positionInParent

In a regular save, a Mixel can store exact pixel fields:

{
  "size": { "...": "..." },
  "positionInParent": { "...": "..." }
}

For templates this is less convenient: pixels depend on a specific resolution.

In .vttp, prefer:

{
  "maket": {
    "preset": "proportional",
    "x": 0.70,
    "y": 0.06,
    "w": 0.25,
    "h": 0.30
  }
}

If maket exists, it recalculates the size and position anew. If there is no maket, Velitask tries to use size and positionInParent.

What Happens When the Mixel Size Changes

When the Mixel canvas size changes, Velitask reapplies the layouts of top-level layers:

• fill stretches to the whole canvas again;
• proportional is recalculated from the new width and height;
• auto applies the indicator's standard placement again.

This is why proportional works well for templates that must live in 16:9, 1:1, 9:16, or 4K.

How Velitask Exports maket

When you export the current Mixel as a template, Velitask saves the layer in template mode.

Important: currently the export always saves the placement as proportional, regardless of which preset was active for the layer. Even if the layer had auto or fill, the template will contain proportional: Velitask takes the layer's current pixel coordinates and size and divides them by the parent size, producing x, y, w, h.

In other words, an active auto or fill preset is not saved as is on export, but is replaced with an equivalent proportional computed from the current layout.

Practical tip: after exporting a template, open the .vttp and, if needed, manually replace the resulting proportional back with auto or fill if you want exactly those presets. For precise control over placement, it is enough to verify that the layers you want use proportional with understandable x, y, w, h.

How to Choose the Right Preset

Common Mistakes

Checking a Layout

1. Make a copy of .vttp.
2. Change maket for only one layer.
3. Apply the template to a test source.
4. Check the layer at the normal Mixel size.
5. Change the Mixel size or export resolution and check again.
6. Make sure the layer does not go beyond the edges and does not cover important elements.

Related Sections

• Mixel JSON and Templates — the general .vttp format and template search rules.
• Mixel and Layers — the basic layer model.
• Mixel Editor — visual layer configuration.
• Supported Formats — where the .vttp format is described.

Indicators and Plugins

An indicator is a "widget" over the video: speedometer, speed text, mini map, slope chart. All indicators are supplied by plugins; the standard set is already built in, and additional ones can be installed separately.

Why This Matters

A Velitask video usually consists of the camera picture itself and a set of overlays with numbers and graphics, so the viewer can see speed, slope, distance, and the current point on the map. In Velitask, these overlays are called indicators.

Indicators are the extensible part. The standard set covers a typical cycling ride / tracking, and beyond that come plugins: indicators for paragliders, boats, cars, custom charts, and so on.

What a Plugin Is

A plugin is a module that brings with it:

• Indicators (new layer types in the Mixel).
• Sometimes — shapes, fonts, icons.
• Its own localization.

A plugin does not change the application core and does not replace existing indicators — it only adds new items to the catalog. A plugin keeps its own service data (for example, the built-in plugin calculates and stores slope groups when a source is imported) in its own table — a separate one for each plugin, not in the shared project data.

Where Indicators Are Visible

Standard Set (Velitask Plugin)

The list may grow from version to version — check the Indicators tab after an update.

Indicator Figures

Some indicators are not a single element but a container of figures: for example, a speedometer may internally have a needle, a scale, and a label. Such figures can be selected.

• On the Indicators tab, expand the indicator card — below the description is a list of supported figures with checkboxes. Checked figures are added together with the indicator when you drag it onto the canvas. (Previously the set of figures was fixed; now you choose it yourself.)
• You can add a figure to an already-placed indicator later: on the Layers tab, right-click the indicator layer → Add figures → choose the figure you need. The submenu is shown only for indicators that support figures.

Installing Additional Plugins

Plugins are delivered as separate .jar files. Velitask looks for them at startup in source folders; by default this is %USERPROFILE%\.velitask\plugins\. In addition, next to the application there is a bundled plugins folder with the built-in plugins — it does not need to be changed.

The simple way. Put the .jar into %USERPROFILE%\.velitask\plugins\ (create the folder if it does not exist). The folder is rescanned in the background — the new indicator will appear on the Indicators tab; no restart is required.

The "Plugins" Window

Opened through the menu Tools → Plugins.... Here you see all discovered plugins in a table with the columns Name, Version, Status (active / loading / reloading / disabled / error / discovered), Indicators (how many indicators the plugin brings), and Actions. At the top — search by name / author.

For each plugin the following is available:

• Reload — re-read the .jar without restarting the application.
• Disable / Enable — temporarily remove the plugin from work (its indicators disappear from the catalog) and bring it back.
• Open folder — show where the .jar was loaded from.

The "Configure sources…" button leads to the settings, where the list of source folders can be extended, removed, or reordered (the Plugin folders section). A double-click on a row opens the detailed plugin card.

If the plugin did not appear — check its status in the "Plugins" window (error) or the application log (%USERPROFILE%\.velitask\logs\velitask.log): there you can see whether the file was loaded.

Indicator Skins

A skin is a named set of appearance settings for an indicator (colors, stroke width, opacity, font, shape) that is applied with one click. A skin saves you from adjusting a dozen sliders every time to make the indicator "look nice".

Skin Sources

In Velitask there are three sources of skins for the same indicator:

For example, for a speedometer the author may declare built-in skins "Default", "Night", "Racing" — they will appear in the "Skin" submenu.

Which Skin Is Applied When Adding

When you drag an indicator onto the canvas, it is added with the settings built into it by default — no skin is applied automatically. If you need a different look, choose a skin manually through the "Skin" submenu (see below) or tweak individual properties.

When opening an existing project, the previously configured indicator appearance is preserved.

How to Change a Skin

1. Open a Mixel.
2. On the Layers tab, right-click the indicator layer.
3. In the context menu, choose the "Skin" submenu.
4. Click the option you need — its settings are applied to the layer immediately.

After a skin is applied, all "visual" indicator properties (Color, Stroke width, Opacity, and so on) are updated. "Non-visual" properties are not touched: if you had a specific sensor source bound or background audio enabled — it stays as it was.

Saving Your Own Skin

If you have built a good combination of settings and want to reuse it:

1. Right-click the layer → Skin → Save to skin….
2. Choose a .vtskin file (new or existing — it will be added to it) and confirm.
3. Enter the skin name — for example, "My night" or "For winter videos".

After that, your skin appears in the "Skin" submenu — and is available exactly like the built-in ones.

.vtskin Files

.vtskin is a small JSON file that stores one or more of your skins for different indicators. What is convenient about it:

• Moving between projects. Copy .vtskin into another project folder — Velitask will find it and show it in the "Skin" menu of the matching indicators.
• Sharing with colleagues. The file can be sent, and the recipient will get your skins in their project.
• One file — many indicators. A single .vtskin can store, for example, speedometer, compass, and slope chart skins — a whole "kit" for one video style.

Velitask searches for .vtskin files in the project folder (recursively). There are no global locations — each project uses its own set of files.

What Is Stored in a Skin

The logic is simple: a skin is about appearance, not about data. So when you switch a speedometer skin, you do not lose its GPX source binding; when you move a .vtskin to a new project, you do not pull someone else's sources into it.

When the "Skin" Menu Does Not Appear

The "Skin" submenu in the context menu is visible only for those indicators whose author declared skins for them (in the plugin). Some standard and custom indicators may have no skins — then the submenu is simply hidden. This is normal.

Related Sections

• Mixel and Layers — what a Mixel layer is in general.
• Mixel Editor — how to add and configure indicators.
• Sensor Telemetry — what data indicators work with.

Importing Video Files

Velitask reads video through FFmpeg and adds files with the .mp4 and .mov extensions to a project. A source is added not through an import menu, but by copying the file into the project folder — Velitask scans it on its own.

Why This Matters

Video is the basis of most projects. All indicators and graphs are overlaid on it. Velitask needs to "see" the video and read its duration, resolution, and (if available) shooting date from the metadata.

Files Velitask Understands

Velitask adds video files with the .mp4 and .mov extensions to a project — these are exactly the extensions the project scanner recognizes. Decoding goes through the built-in FFmpeg (JavaCV), so a wide range of codecs is usually understood inside the container:

The exact set of codecs depends on the capabilities of the bundled FFmpeg build; Velitask does not check them against a separate list. If your file is in another container (AVI, MKV, WebM, MTS/AVCHD, and so on), resave (remux) it to .mp4 or .mov with any video editor — then Velitask will pick it up.

How to Add Video to a Project

Velitask works with a project as a folder on disk. There is no separate "import" command or dragging files into the window — a source is added through the file system:

1. Open the project folder in File Explorer (the one you specified when creating the project).
2. Copy a .mp4/.mov video file into it. You can arrange files into subfolders — the folder structure is reflected in the source tree.
3. Velitask periodically scans the project folder (roughly every 3 seconds) and adds the file on its own — a new source appears in the tree on the Project tab (the tree mirrors the structure of folders and files), and metadata-reading progress appears on the Tasks tab.

Several files are added the same way — just copy them all into the project folder.

What Happens After Adding

1. Metadata reading. Resolution, duration, and creation time (creation_time), if present in the file metadata. fps and codec are not written into the source database. If the file has no creation_time, the shooting date stays unset — the file modification date is not substituted.
2. Device Profile creation. Velitask automatically creates a new Profile or links the source to an existing one based on hints from the file metadata (the make, model, device_make, device_model, encoder tags), not on the file name. If there are no hints, the source inherits the default Profile.
3. Frame cache preparation. Preview frames are read on demand when you scrub the timeline. Long preliminary decoding is not started, saving time and space.

The file stays in the project folder — Velitask references it in place. Do not delete or rename the video outside the application while working with the project.

Where Video Is in the Mixel

After import, the video is not on the canvas yet — you need to place it as a layer:

1. Open the Indicators tab and find the video indicator.
2. Drag it onto the canvas.
3. In the layer properties, select your video source.

See Mixel Editor for details.

Audio

Audio comes from the video layer: the video indicator has an audio property, and only when it is enabled does the track play in the player and make it into the export. Volume is set in the same place.

On export, audio is always re-encoded to AAC: even if you choose the "Copy" option (no transcoding), Velitask switches to AAC for an incompatible track, so a bit-for-bit copy of the original audio track is not guaranteed.

Related Sections

• Supported Formats — detailed extension list.
• Importing GPX — adding a GPS track to video.
• Mixel Editor — how to place video as a layer.
• Troubleshooting — if a file does not open.

Troubleshooting

• The file did not open and the log has an FFmpeg error. Most likely the file is damaged or it is a stream without a header. Re-save the file in any video editor and try again.
• Velitask does not see the shooting date. Not all files contain date metadata (creation_time). If it is missing, the shooting date stays unset — the file modification date is not substituted, and you need to set the correct time manually through the Device Profile.
• "Duration 0 sec." The file was imported, but the player shows an empty timeline. This happens with files without a correct index. Re-saving the file in any video editor helps.

Importing GPS Tracks (GPX)

Velitask reads GPX files directly: a track becomes a set of sensors — Geo (coordinates), Distance, Elevation, Speed, Slope. A source is added by copying a .gpx file into the project folder; Velitask picks it up on its own. Large tracks are read in the background.

Why This Matters

A GPS track is the main source of "numbers" for a typical project: speed, distance, coordinates for the mini map, elevation, slope. All indicators over the video usually work from GPX.

What Velitask Does With GPX

After importing one .gpx, Velitask automatically creates several sensors — separate data channels:

From the additional point fields, Velitask recognizes only temperature (the temperature / temp / atemp tags) and creates a Temperature sensor for it. Other GPX extensions (power, cadence, heart rate) are not parsed at this stage.

How to Add a Track

Like video, GPX is added through the project folder — there is no separate import command:

1. Copy the .gpx file into the project folder (or a subfolder) with any file manager.
2. On its next scan of the folder, Velitask recognizes the extension and reads the track on its own.

What Happens Next

1. In the tree (the Project tab), the your-track.gpx file appears in the folder where you placed it. Expand the file node — the sensors (Geo, Distance, Elevation, Speed, Slope, …) load on first expansion.
2. Progress is visible on the Tasks tab. Very large tracks (tens of thousands of points) take noticeably longer to read.
3. After completion, the sensors are available for binding to Mixel indicators.

Time in GPX

Timestamps in GPX are read as ISO instants (UTC) — Velitask takes them "raw", as they are in the file. From there, the source time goes through the common Time Model: the resulting UTC is produced through the Device Profile, not from the GPX itself.

The Profile for the source is chosen automatically: a profile-attachment task runs during scanning. For GPX, the device name hint is taken from the creator attribute of the root <gpx> tag. If there is no matching device, the source inherits the default Profile from the project root. See Time Model and Time Synchronization for details.

If GPX Has the "Wrong Duration"

GPX is a sequence of points with timestamps. If the first point has time T0 and the last has T1, the sensor duration will be T1 − T0. This is not tied to the video duration: one track may cover several video clips or, conversely, be shorter than the clip.

After import, you place layers using these sensors; Velitask automatically shows values only in the part of the timeline where the track exists.

Several Tracks in One Project

You can import several GPX files into one project: each becomes its own source. This is useful when you record a track on several devices at the same time (watch + bike computer) or want to compare tracks.

When creating an indicator layer, you choose exactly which GPX source to take data from.

Related Sections

• Sensor Telemetry — what a sensor is and how sensors are stored.
• Sensor Catalog — all types and measurement units.
• Time Model — why a Device Profile is needed.
• Database Editor — how to inspect imported points.

Troubleshooting

• GPX imported, but Speed is zero everywhere. The points have identical timestamps (or no time at all). Velitask cannot calculate anything. Use another track source.
• There is no elevation and no graph. Not all GPX files write <ele>. Without it, slope cannot be calculated either.
• Import takes a very long time. This is normal for large tracks — they can contain tens of thousands of points. Watch progress on the Tasks tab.
• Track points are "shifted" in time. This is a Device Profile issue, not an import issue. See Time Synchronization.

Sensor Telemetry

A sensor is one measurement channel bound to a source: speed, distance, power, coordinates, temperature. Sensors are stored in the project database as sequences of "atoms" (points with a timestamp).

Why This Matters

Every indicator on the Mixel canvas works with data — it takes that data from a sensor. To understand what an indicator will show and where the numbers come from, it helps to picture how sensors are organized.

What a Sensor and an Atom Are

One source can contain several sensors of different types. From one GPX this is typical: Geo + Distance + Elevation + Speed + Slope.

Where Sensors Come From

For more about types, see Sensor Catalog.

How Sensors Are Visible in the Project

1. Open the source tree (the Project tab).
2. Expand any source to see the list of its sensors.
3. Double-clicking a sensor opens the Database Editor for that sensor (see Database Editor).

Storage

• All atoms are saved in the project database. This is a local file — no clouds, no network requests.
• Large tracks can produce tens and hundreds of thousands of atoms. The database handles this without problems; the Database Editor uses paged display for viewing.

Raw and Processed Values

Velitask does not "tidy up" values for you: if a GPX track contains speed spikes (for example, 200 km/h on a bicycle because of a GPS glitch), they enter the sensor as is, and the indicator shows them too.

That said, the import is not entirely verbatim:

• derived sensors are built from the source coordinates and elevation — Distance, Speed, Slope (and in GPX, Speed itself);
• points with zero/empty coordinates and points with non-monotonic time (time not greater than the previous one) are skipped;
• in .tmg telemetry, for sparse channels (pressure, temperature, tilt, electric, wheel, cadence), the last known value may be carried forward if a given row does not fill the channel.

What you can do about this:

• Edit atoms manually through the Database Editor — replace or delete peak values.
• Use the Sensor Row Editor to see how one point affects an indicator.

Sensor and Time

Each atom carries its own raw device time. Through the Device Profile, it becomes UTC and lands on the shared Mixel timeline. That is why the correct Profile is not a "formality" but the basis of correct synchronization.

Related Sections

• Sensor Catalog — all types and units.
• Importing GPX — the main way to get sensors.
• Database Editor — viewing and editing atoms.
• Sensor Row Editor — previewing a single atom.
• Time Model — how raw time becomes UTC.

OSM Tiles

Velitask shows the mini map through OpenStreetMap (OSM). Tiles (square map pieces) are downloaded as needed and cached to disk, so repeated viewing of the same region works offline.

Why This Matters

A mini map with a current-position marker and track is one of the main indicators in cycling and travel videos. Velitask takes the map image from OpenStreetMap servers. To make this fast, independent of the internet at the export stage, and gentle on OSM servers for every frame, tiles are cached locally.

How It Works

1. When the Map indicator ends up in a Mixel, it determines the needed region and zoom.
2. The map is split into square tiles (256×256 pixels).
3. Velitask checks whether each tile is in the local cache:
   • Present — takes it from there (instantly).
   • Missing — downloads it from the OSM server in the background and stores it in the cache. For an already rendered area, a placeholder / previous level is used.

Where the Cache Is Stored

By default the cache is stored inside the project folder: <project>\.cache\OSM\.

This behavior is set in Settings → Files and folders:

• the OSM tile cache folder field — the path to an external shared cache folder;
• the Store inside the project folder checkbox (enabled by default) — while it is enabled, the path field is not used and each project's cache lives in its .cache\OSM\ subfolder. Clear the checkbox to store the tiles of all projects in one shared folder at the specified path.

The structure is standard for OSM (by zoom level and tile coordinates). The cache is not cleaned automatically: over time the folder may grow to hundreds of megabytes or gigabytes if you have traveled across many regions in your projects.

It is safe to delete the cache — Velitask will simply download the needed tiles again. This does not affect project results in any way.

Offline Work

If you have rendered the map for the needed region at the needed zoom levels once, it is available offline afterward. A useful technique before a trip without internet:

1. Import the GPX in advance.
2. Place the Map indicator into the Mixel.
3. Scrub the entire timeline at the needed zoom level — Velitask will load all tiles along the track.
4. You can then work without network access.

OSM Server Limits

OpenStreetMap.org servers are public and free, but they have a fair-use policy: dozens of simultaneous requests from one IP may lead to a temporary block. Velitask tries to respect this: downloading goes through task queues with delays between requests; when the server reports that the limit is exceeded (429), a backoff pause and retry kick in; tiles that have already been downloaded or are queued are not requested again.

The raster tile source is https://tile.openstreetmap.org/{z}/{x}/{y}.png; it cannot be changed in the interface.

What Is Shown on the Map

The map itself is just the background. Over it, the Map indicator draws:

• Track — a line through Geo sensor points.
• Current position marker — at the location corresponding to the cursor's UTC time in the Mixel.
• (Optionally) direction and information about the current point — depending on the indicator settings.

Vector Map Data (Overpass)

Besides raster tiles, Velitask can pull in OSM vector data — settlement names and administrative boundaries. They come not from the tile server, but through the Overpass API, and are used to label places and draw boundaries over the map.

The Overpass server is configured in Settings → Maps (OSM), the Overpass API endpoint field:

• you can choose one of the preset addresses or enter your own URL;
• the change applies after reopening the project.

Loading runs as background tasks (visible on the Tasks tab): vector data and boundaries are downloaded separately (the "Downloading map data..." task), settlements separately (the "Downloading places..." task). The raster tiles themselves are loaded by the "Downloading map tiles..." task. The result is cached the same way as tiles, so repeated display of the same region works offline.

Related Sections

• Importing GPX — where the map track comes from.
• Mixel and Layers — how to add a map as a layer.
• Mixel Editor — Map indicator settings.

Troubleshooting

• The map is gray and tiles do not load. Check your internet access. If you are behind a proxy, Velitask has no built-in proxy setting and you will have to rely on the system one.
• The map works, but there is a "hole" in one place. The cache for these tiles is broken — delete the corresponding subfolder in .cache\OSM (or in the shared cache folder, if one is set) or just the whole cache.
• The cache takes a lot of space. This is normal for active users. Delete the project's .cache\OSM folder (or the shared cache folder) — Velitask will recreate it as needed.
• Tiles look blurry. You are viewing the map at a zoom level for which the proper tile level has not been loaded. Scroll/change the zoom — Velitask will load the needed ones.

Importing Images

In short: besides video and tracks, Velitask can work with an image source — a static picture as the basis of a Mixel. Handy for posters, title frames, and overlays on a solid background. You add it by copying the file into the project folder. Recognized formats: .jpg, .jpeg, .png, .bmp, .gif, .tif, .tiff.

Why This Matters

Not everything in a project is moving video. Sometimes you need a still background: a title frame for a ride, a backdrop for a set of indicators, a splash image. An image source gives you exactly that — a static picture on top of which the same layers and indicators work as they would over video.

How to Add an Image

Just like video and tracks — through the project folder:

1. Copy the image file (.jpg, .png, etc.) into the project folder or a subfolder.
2. On the next scan, Velitask adds an image source node with a thumbnail to the tree (the Project tab).
3. A background task reads the image dimensions (width and height). The source start time is taken from the file modification date, and the duration is fixed — 60 seconds. EXIF and capture parameters are not read.

The file stays in the project folder — Velitask references it in place.

Working with an Image Source

• Double-clicking the node opens the editor — the same Mixel canvas as for video, but with a still frame at its base.
• Any indicators and figures can be added on top of the image (see Mixel Editor).
• In the project tree the source is shown with a thumbnail — Velitask draws it through the Mixel composition.

Export

An image source can be exported:

• as an image (a single frame with the overlaid indicators);
• as a video — a static picture with overlays (the duration comes from the source period, 60 seconds by default; for example, a splash before a ride).

Every export lands in the render log.

Related Sections

• Supported Formats — which raster formats are read.
• Mixel Editor — overlaying indicators on an image.
• Image Export — save a frame as PNG.

Troubleshooting

• The image did not appear in the tree. Check that the format is supported (the main raster formats). If there is a problem, look at the application log (%USERPROFILE%\.velitask\logs\velitask.log).
• Wrong source time. The start time of an image source is taken from the file modification date, so it may not match the actual moment of capture. If the time matters for synchronization, set it manually through the Device Profile.

Sources Panel

The left Project tab is the tree of all project sources and sensors. The tree reflects the contents of the project folder: whatever is in the folder (video .mp4/.mov, GPX, images, telemetry .tmg) is what is shown. Double-clicking a node opens the corresponding editor.

Why This Matters

Velitask stores all project data (video, GPX, images, telemetry) as files in the project folder and shows them as sources in one tree. From this tree, you:

• see everything in the project in one place;
• quickly open data for viewing and editing;
• create a timeline from a source.

The tree contents are defined through the file system: to add, delete, rename, or group sources into folders means doing it with the files in the project folder (see Importing Video). Velitask picks up the changes during automatic scanning.

How the Tree Is Organized

Tree nodes:

Nodes have their own icons by type.

What Is Done in the Tree and What in the Project Folder

In other words, you change the contents of the project in the file system, while the tree is its "mirror" plus a few opening commands.

Icons and Thumbnails

Each tree node has an icon by type (folder, video, GPX, image, telemetry, sensor). For file sources, a thumbnail is shown instead of the icon — a frame or preview from the project database, if one has already been built.

Opening a Node

• A source (video, GPX, image, telemetry) — double-click or Enter opens the Mixel Editor.
• A sensor — double-click or Enter opens the sensor data table.

Context Menu

Right-clicking a node opens a context menu. The set of items:

• Information — show a summary of the source (type, time, duration, attached Device Profile).
• Attach to device... — attach a Device Profile to the source.
• Create timeline — create a timeline from the selected node. Available for a source, a folder, and the project root; not for sensors.

A layer in the Mixel is created from the Indicators panel (see below).

Related Sections

• Importing Video, Importing GPX — how to populate the tree.
• Sensor Telemetry — about sensors inside sources.
• Mixel Editor — how to assemble a composition from sources.
• Time Synchronization — about Device Profiles.

Time Synchronization

For indicator values to match what happens in the video, every source must have the correct Device Profile. This section is practical: where to look, how to edit, how to check.

Why This Matters

If the speed indicator says "37 km/h" while the person in the video is standing still, one of the sources is shifted in time. Velitask lives in a single UTC scale, but the correctness of that UTC depends on the Device Profiles through which raw time is brought to UTC.

See Time Model for the theory.

Where and What to Configure

All Profiles are on the Devices panel on the left side of the window. Each Profile is a separate card; double-clicking a card opens the device editor.

Typical Configurations

Action-Camera Video

Cameras write local time according to their internal clock. Ask yourself:

• Which time zone was the camera set to? This is the value in the tz field.
• Was the clock off by several seconds? This is the offset.

Check: take a frame linked to something objective (start signal, passing a known point) and compare it to the same moment in GPX. A difference in seconds means you adjust the offset. A difference in hours means you adjust the time zone.

GPX Track

In the vast majority of cases, GPX uses UTC with offset 0. Do not change it unless you are sure the device writes differently.

Several Sources From One Device

If you have three clips from one GoPro, it is convenient to assign one Profile, "GoPro Hero 11", to all three. Bind it to the common parent folder (or the root) through the Attach to device dialog — then all nested clips inherit the Profile down the chain, and editing one card affects all clips. Most often Velitask recognizes such clips on its own through the auto-detection hints.

Synchronization Scenario

1. Import video and GPX (see Your First Project).
2. Open the Devices panel. On import, Velitask automatically creates a default Profile on the root for each source type (a separate one for video, a separate one for GPX) and binds specific sources through the auto-detection hints. A separate Profile per source is created only when the metadata yields a meaningful device name.
3. For GPX, keep UTC, offset 0.
4. For video:
   • Set the camera time zone (the one its clock used during shooting).
   • Keep the offset at 0 for now.
5. Place Video and Speed (text) layers into the Mixel (with speed from the GPX sensor).
6. Find a moment you can compare precisely: the video shows a stop, and the GPX speedometer also drops to zero.
7. If the stop in the video and zero speed in GPX differ by N seconds, enter the offset into the video Profile. Choose the sign according to the field hint: a fast clock → a negative value, a slow clock → a positive value. If you guessed the direction wrong, the shift grows; then flip the sign.
8. Confirm the change and check again. Adjust if needed.

Group Synchronization

Profiles are not copied — the same Profile is bound to several nodes. Once the camera Profile is configured, bind it to a common folder (or the root) through the Attach to device dialog: all nested sources of this type inherit the Profile down the chain. You can remove the binding with the ✕ remove profile button in the chain of the "Time correction" block.

Checking After Edits

• Move the cursor to different parts of the timeline and make sure the values move together with the video.
• For long tracks, checking the beginning and the end is usually enough. If both points match, the middle almost always matches too.

Related Sections

• Time Model — the theory behind what you are adjusting.
• Importing GPX, Importing Video — what enters the tree.
• Troubleshooting — common desynchronization cases.

Troubleshooting

• Shift by exactly one hour (or N hours). This is the time zone. The camera used a different time zone from the one set in the Profile. Set the correct time zone and keep the offset at 0.
• Shift by an arbitrary number of seconds. The device clock was inaccurate. Adjust the offset.
• The shift is different in different parts of the video. Most likely, the clock drifted noticeably during recording — typical for older cameras. A Profile cannot fully fix this; use only part of the video or accept the error.
• GPX and video match perfectly at the start but diverge at the end. Same case: clock drift. This is especially common with cheap GPS devices whose time is not corrected from satellites.

Mixel Editor

Mixel is the main composition editor. Here you add layers, bind them to sources, move and scale them, play back, and check the result.

Why This Matters

Everything that enters the final video passes through the Mixel: a video layer at the bottom, indicators over it. The Mixel Editor is not a separate window, but the central Velitask player itself: what you see on launch is the editor.

Main Elements

Adding a Layer

Layers are added from the indicator catalog in the Indicators panel. This is the only place from which something is dragged onto the canvas in Velitask; there is no dragging of sources from the Project tree onto the canvas.

The Add button in the Layers panel simply opens the Indicators panel — selecting and adding happen there.

By Drag-and-Drop

1. Open the Indicators panel.
2. Find the indicator you need (for example, Speedometer).
3. Drag it onto the canvas. The drop target is the canvas only; there is no dragging into the layer list.
4. Velitask creates the layer and opens its properties on the right.

Through the Catalog Context Menu

Right-click an indicator in the Indicators panel:

• Add to mixel — add it to the Mixel root;
• Add into selected layer — add it inside the selected layer. The item is available only when an indicator layer of the same type as the one being added is selected.

After the layer is created, link it to the needed source in its properties (see below).

Binding to a Source

An indicator layer usually needs a source sensor. This field is shown in properties. For most types:

• One indicator uses one sensor. For example, Speedometer is linked to one speed sensor.
• Some indicators can accept several sensors (for example, Map + track + optional marker).

If no source is set, the indicator shows a placeholder or "—".

Moving and Scaling

Layer properties include coordinates, width, and height. Ways to edit them:

• Move directly on the canvas (drag-and-drop).
• Resize using corner or edge handles.
• Enter exact values in properties: the x, y, Width, Height fields are numeric fields with spinners (you can type a number or nudge it by ±).
• Enable anchor binding (set "to the bottom-right corner of the canvas with a 24 px margin").

The Layout block is always at the bottom of the properties panel — below the layer name and the indicator parameters.

Most values are set either in pixels or as percentages of the canvas. Percentages are convenient if you plan to export in different resolutions, because the layer scales automatically.

Layer Order, Name, and Nesting

Right-clicking a layer in the Layers panel opens a context menu. Besides skins and deletion, it includes:

Layer name. In the list, a layer is shown under its name if you set one, otherwise as <type> #<short code> (for example, "Speedometer #a1b2c3"). You can rename a layer in the Name field at the top of the properties panel; an empty name restores the automatic one.

Nesting. A new indicator is added inside the selected indicator layer if one is selected in the tree — otherwise into the Mixel root. This lets you assemble composite blocks: for example, place text and an icon inside a common container. In the layer list this is visible as nested nodes.

Playback Speed

The player properties panel has a Speed field — the playback and export speed (a numeric field with spinners, 1.0 by default). Values greater than 1 speed up the clip (for example, 2.0 is twice as fast), values less than 1 slow it down.

When the speed differs from 1.0×, a badge with the current value appears on the player. The speed is also applied on export, but with one limitation: at a speed ≠ 1.0×, audio is not exported (see Video Export).

Layer Skins

Right-click an indicator layer → Skin submenu to see built-in and custom visual options. One click changes the whole set of visual properties (colors, stroke, opacity) at once. See Indicators and Plugins → Indicator Skins for details.

Video Layer

The video layer is special: its frame changes depending on the current UTC time and Device Profile. Outside the video source range on the timeline, the layer shows a black background or empty content depending on settings.

Several video layers can be placed side by side, for example picture-in-picture (PiP) or comparison between two cameras.

Saving

A Mixel is saved as part of the project: all your layer moves, layer properties, and indicator settings are written to the project database. Saving is not automatic — changes are written with File → Save (or Ctrl+S). While there are unsaved changes, the Save item is active; after the write it dims again.

If you need to reuse a composition in other projects, export it as a .vttp template through File → Export → Template.... Regular editor work and a JSON template describe the same composition: the editor changes it visually, while JSON changes it structurally. Details: Mixel JSON and Templates.

Related Sections

• Mixel and Layers — the theory.
• Indicators and Plugins — what is in the catalog.
• Sensor Telemetry — what data indicators use.
• Video Export — what the Mixel becomes as a file.
• Mixel JSON and Templates — .vttp export and application.
• Mixel Layouts in JSON — precise layer placement in .vttp.

Database Editor

The Database Editor is a table view of the project's sensor atoms. It opens for a sensor in the Sensor data tab: it shows rows with timestamps and values and lets you switch the source/sensor, the time mode, and page through the data.

Why This Matters

Most users work with sensors through indicators and never think about the table under the hood. But sometimes you need to "look into the data": check that import did not lose points, find a speed spike, or see at which moment a GPX track changed from movement to stop.

For all of this there is the Database Editor — a dedicated project tab, Sensor data.

How to Open

• Double-click a sensor in the source tree.
• Select a sensor in the tree and press Enter.

The Sensor data tab opens with a table of the selected sensor's data. The project uses a single such tab: opening another sensor switches it to the new "source + sensor" pair.

Main Window Elements

The time mode and page size are remembered between sessions. The ⟲ button resets the column settings (units, widths, sorting) for the current sensor type.

Table Columns

Columns depend on the sensor type. Common to all:

Additional columns by type:

See Sensor Catalog for details.

What You Can Do

The table is for viewing only: editing cells and deleting rows is done in the Sensor Row Editor, not in the table itself.

Related Sections

• Sensor Telemetry — what a sensor atom is.
• Sensor Row Editor — opens from the table for a specific row.
• Sensor Catalog — all types and columns.

Sensor Row Editor

The Sensor Row Editor shows one sensor point (one database row) next to a Mixel preview at that moment. It is useful when you need to understand exactly how one point affects indicators and video.

Why This Matters

Viewing data in the Database Editor shows it "in a table". But sometimes you want to see exactly what the Mixel will show at that instant. For example:

• See how a specific atom value looks in the frame and in the indicators.
• Understand which track point a specific atom falls on.
• Check that an imported atom really matches a video fragment.

The Sensor Row Editor is a small Mixel player bound to the selected atom.

This is a view mode. Atom values are only displayed for now — you cannot change them directly in the form (editing is planned for the next version). So the editor is used for analysis, not for correcting data.

How to Open

In the Database Editor, select a row in the table and:

• double-click it, or
• press Enter.

A tab opens with two halves:

• Left: a form with the atom fields (view only).
• Right: a Mixel preview at the atom's moment in time.

What Is Inside

Left Half: Atom Form

• Fields by sensor type (for example, latitude/longitude for Geo, power value for Watt).
• The field labels are the localized column headers (the same as in the Database Editor table), and the units and value format come from the settings of that same table.
• All fields are read-only — values are shown but not edited.

Atom Navigation

At the bottom of the tab there is a footer with ‹ and › buttons — they move to the previous / next atom of the same sensor by time. Next to them the footer shows the current row status as #<id> · <table>.

When you move, the preview on the right rewinds to the new atom's moment in time on its own.

Right Half: Mixel Preview

This is a full mini Mixel player:

• A canvas with the same layers as the project's main Mixel (or with a simplified set — this depends on the preview settings).
• Playback buttons: to start, previous frame, Play / Pause, next frame, to end.
• A slider and date/time fields — they let you put the cursor at a needed point near the atom.
• The mouse wheel over the canvas scrubs one frame at a time (with Shift held — by 10 frames).

The preview's top bar (on the right) has a Save button and an Auto-save checkbox. They apply to the preview Mixel itself, not to the atom value: they remember how the preview is configured (layers and their parameters). If you enable Auto-save, the preview changes are saved automatically after a small delay.

"Copy main mixel"

The preview's top bar has a Copy main mixel button. It replaces the preview Mixel with a copy of the main one — useful when you want to see the atom in the context of the full composition rather than the simplified preview scheme.

Typical Scenario

1. In the Database Editor you found a suspicious atom (for example, speed 200 km/h).
2. Double-click (or Enter) → you open it in the Sensor Row Editor.
3. In the right preview you see the corresponding frame and indicators.
4. You see: the bicycle is standing still on the video, but the indicator still shows 200 km/h — a GPS spike.
5. Use the ‹ / › buttons to move to neighboring atoms and compare their values to gauge the scale of the spike.
6. Note the problematic atom to come back to it later — correcting the data is done separately (see Sensor Telemetry).

Related Sections

• Database Editor — opens before this editor.
• Sensor Telemetry — what an atom is.
• Mixel and Layers — what the preview shows.

Video Export

A finished Mixel is saved to a video file through File → Export → Video → Video…. H.264 (MP4) and QTRLE (MOV) are supported; the "ProRes (mov)" item in fact also produces a QTRLE-MOV. All frames are rendered through FFmpeg in a background task.

Why This Matters

The final purpose of a project is to get a file you can send to friends, upload to YouTube, or show on a TV. Velitask builds a video file from the Mixel: the video layer + all indicators over it, plus audio from the source video.

Starting Export

1. Open the project and the assembled Mixel.
2. File → Export → Video → Video…
3. The Export video dialog appears with its settings.
4. Fill in the parameters (see below) and click OK (or Cancel to close without exporting). After OK you choose the file to save.
5. Progress appears on the Tasks tab. When complete, the finished file is in the selected folder.

You can keep working in Velitask while export runs in the background.

Dialog Parameters

Range

You can export only part of a Mixel — for example, a single ride out of the whole project. These are offsets from the Mixel start, not absolute UTC time; there is no separate duration field.

Codec and Container

Preset (Quality) and FPS

The dialog has no separate fields for resolution or low/medium/high-style presets. The resolution of the output file equals the Mixel size (the base canvas is Full HD 1920×1080). The Preset in the "Video" section is a set of quality parameters for H.264:

Presets affect H.264; for the QTRLE/ProRes sections the set of fields is different (lossless). FPS is set with a spinner (valid range 0.1–60), defaulting to the frame rate from the project settings. The higher the fps, the longer the export and the larger the file.

Audio

Audio is turned on with the Include audio checkbox (for video export it is on by default). While the checkbox is cleared, the preset selection and its fields are disabled. There is no "no audio" option in the preset list — the checkbox is responsible for that.

About "Copy". The dialog checks compatibility and shows a hint under the preset: either "✓ Compatible — stream copy will be used", or "⚠ Auto-fallback to AAC Medium: …" with a reason (no enabled audio sources, several sources need to be mixed, layer volume ≠ 1.0). In practice, even when "compatible" is shown, the audio is still encoded as AAC Medium: a real stream copy is not implemented in the export pipeline.

If a playback speed other than 1.0× is set (see Mixel Editor → Playback Speed), audio is not exported — the Include audio checkbox is turned off, and the dialog shows the warning "Speed changed — audio is not exported".

Export History

Every export run (video, an individual layer, an image) is recorded in the Render Log: it shows what was rendered and with which settings, lets you open the result and repeat the render. Log entries are then used as items when assembling timelines for editing software.

How Export Works

1. Velitask walks the timeline from "Start time" to "End time" with a step of 1/fps.
2. For each frame, it assembles the Mixel: video sources, indicators, shapes — everything is drawn into one image.
3. The image is passed to the selected codec (through FFmpeg).
4. Audio is taken from the audio source and encoded as AAC (at the chosen bitrate); stream copy is not applied.
5. Finished frames and audio are packed into the container (MP4 or MOV).

Export speed depends on:

• Resolution and fps.
• The number and complexity of layers (especially maps and graphs).
• CPU performance (decoding and encoding are software-based).
• Disk speed (lots of source-video reading and output-file writing).

Related Sections

• Video Export Presets — save a set of encoding settings.
• Supported Formats — details about input/output formats.
• Image Export — for a poster or preview.
• Troubleshooting — if export fails or hangs.

Troubleshooting

• Export is "stuck" at N%. Open the logs (%USERPROFILE%\.velitask\logs\velitask.log). Sometimes FFmpeg hits a damaged fragment of the source video.
• There is no audio in the file. Make sure the Include audio checkbox is set. If it was cleared automatically — the Mixel probably has a playback speed ≠ ×1: at such a speed audio is not exported. Audio is always encoded as AAC, so there should be no incompatibility with MP4.
• The file size is very large. You most likely selected QTRLE (or "ProRes", which also produces a QTRLE-MOV). This is normal — it is a lossless master codec. For sharing or publishing, use H.264 (mp4).
• Export takes too long. Lower the fps or choose a "lighter" quality preset (Economy). The resolution is determined by the Mixel size — shrink the canvas if needed. Maps and graphs are the heaviest indicators; temporarily disable them if you need a quick export.

Image Export

One Mixel frame is saved as PNG through File → Export → Image…. Useful for posters, video previews, and social networks.

Why This Matters

Sometimes you do not need a video file — you need one nice image with overlaid indicators:

• a poster for a YouTube video;
• an illustration for a blog;
• a frame for a report or presentation;
• a quick "snapshot" of an interesting moment.

Image export does exactly this: it renders the Mixel at one moment in time and saves it to a file.

How to Do It

1. Place the timeline cursor on the needed frame.
2. File → Export → Image…
3. In the Create image dialog, specify the path and name of the output file (the format is PNG only).
4. Click Save.

The image is rendered at the native Mixel size. The snapshot is saved synchronously, right at the moment you click; a separate task is not created in the Tasks section.

The snapshot is rendered without the Mixel background, so the resulting PNG may contain transparent areas.

Related Sections

• Video Export — for a video file.
• Supported Formats — detailed list.
• Mixel Editor — configuring the composition before export.

Video Export Presets

An export preset is a ready-made set of encoding parameters chosen from a list in the File → Export → Video… dialog. There are two independent kinds of preset: a video preset (H.264 quality) and an audio preset. Each one sets all of the corresponding codec's parameters with a single choice.

What a Preset Is in Velitask

Presets in Velitask are a built-in list of ready-made sets, not user-saved named configurations. You cannot create your own "YouTube 1080p" preset and save it under a name — there is no "Save preset" button or name field in the dialog.

Instead, you choose a suitable item from the built-in list, and if none fits, you switch to Custom mode and edit the parameters by hand.

Do not confuse export presets with Mixel templates. An export preset controls how the video file is encoded. A Mixel template controls which layers and indicators are in the composition. For more on composition templates, see Mixel JSON and Templates.

Two Preset Lists

The export dialog has two separate Preset fields — in the "Video" section and in the "Audio" section. They are chosen independently of each other.

Video Presets

All built-in video presets are H.264. They differ in the "quality / file size" balance (internally — the CRF parameter and the x264 encoding speed):

Audio Presets

The "Copy" preset works only when the source audio can be passed through without transcoding. When that is not possible (for example, there is no enabled audio source, there are several sources and a mix is needed, or a layer's volume has been changed), the dialog shows a hint, and on export it automatically switches to AAC Medium.

How to Use

1. Open the File → Export → Video… dialog.
2. In the Video section, choose the needed preset in the Preset list. The codec parameters fill in automatically.
3. If you wish, refine the Codec and FPS — these are separate fields nearby and are not part of the video preset.
4. In the Audio section, choose the audio preset (or clear the Include audio checkbox if you don't need audio).
5. Click OK to start the export, or Cancel.

Custom Mode

If you choose Custom, fields with the specific codec parameters (for video) or audio parameters (for audio) expand under the list, available for manual editing.

Switching to this mode also happens automatically: as soon as you manually change any codec parameter field, the choice in the Preset list switches to Custom itself — to make it visible that the values no longer match a ready-made preset.

What Is Included in a Preset and What Is Not

Remembering the Choice

Velitask remembers the last chosen video and audio presets (as well as the manual values for "Custom" and the state of the "Include audio" checkbox). This data is stored in the current project's settings (the project's SQLite settings table), so on the next export of the same project the dialog opens with the previous choice.

This is not a setting shared across all projects: in another project the choice memory is its own.

Related Sections

• Video Export — parameter details.
• Mixel and Layers — what actually goes into the export.
• Mixel JSON and Templates — .vttp composition templates.
• Supported Formats.

Render Log

In short: the render log is the history of all exports in a project (video, layers, images). Open it via Tools → Render log. From the log you can open a result, copy its path, re-render an entry with the same settings, and delete what you no longer need.

Why This Matters

When you export overlays and compositions one by one, files pile up fast: the speedometer of one ride, the map of another, a whole Mixel of a third. The render log gathers them into a single table — you can see what was rendered, when, with which settings, where the file lives, and whether everything is fine.

The log is also the foundation for timelines: its very entries become items when you assemble a timeline for an editing application.

How to Use

1. Open a project.
2. Tools → Render log — a tab with the table of entries opens. If the tab is already open, calling it again simply activates it.
3. Every export (video, layer, image) automatically adds a row to the log.
4. Double-clicking a row opens the folder with the file in your file explorer.

The tab is restored together with the project — you don't need to open the log again every time.

Toolbar

Table Columns

The time in the log is shown in the local zone rather than in UTC like the rest of the application — so that the clock tells you exactly when you started the render.

Details Panel

Below the table are two parts for the selected entry:

• Preview on the left: the first frame of the result. For entries with transparency (alpha channel) the background is drawn as a checkerboard so the transparent areas are visible.
• Metadata on the right: a header like <indicator> @ <source>, the full file path, file size, resolution, a "FPS · codec · alpha" line, the source Mixel size, the layer's position within the Mixel, and the creation and completion times (in your time zone).

The field labels on this panel are shown in English in the current version: File (path), Size (file size), Resolution, FPS/Codec (FPS and codec), Source mixel (source Mixel size), Position (layer position), Created, Finished.

Entry Context Menu

The ⋮ button in a row (or a right-click):

Items that work with the file are disabled if the file is no longer in place.

Re-Render

Render again is handy when you've tweaked a layer and want to rebuild the same overlay without configuring the export from scratch. Velitask:

1. Opens the editor of the original source.
2. Finds the needed layer by its identifier.
3. Re-exports it with the previous parameters — the same file, codec, frame rate, and transparency support.

The result overwrites the same log entry rather than creating a new one. The same repeat is available right from the layer tree of the Mixel editor — the Export… item in a layer's context menu (for top-level layers that already have a rendering history).

Where Entries Come From

The log is populated by any export from the source editor:

• Video Export of a whole composition;
• export of an individual layer;
• Image Export.

Related Pages

• Timelines — assemble log entries into a timeline for an editing application.
• Video Export — where the entries come from.
• Mixel Editor — re-rendering from the layer tree.

Troubleshooting

• A row with the ✗ icon (error). Open the logs (%USERPROFILE%\.velitask\logs\velitask.log) — the cause is usually the source video or a lack of disk space. Fix it and use Render again.
• The "Open file" / "Open folder" items are greyed out. The file was deleted or moved. You can remove the entry via Delete record or re-render it via Render again.
• The time doesn't match the project timeline. That's normal: the log shows the local time of the render start, while the Mixel works in UTC.

Timelines

In short: a timeline gathers finished renders and video sources within a shared time window and exports them to FCPXML, XML (FCP7), or OTIO — so you can open the whole layout in DaVinci Resolve, Final Cut Pro, Premiere, and other editing applications. Open it via Tools → Timelines.

Why This Matters

Velitask renders individual overlays and whole compositions well, but many people do the final edit in a professional editor. To avoid arranging clips and overlays there by hand, Velitask transfers the entire layout: which items, where in time, on which track, in which position and size. In the editing application you get a ready-made timeline — you only need to finish it.

Timeline items come from the render log and the project's video sources.

How to Create a Timeline

1. In the Project panel, right-click a source or folder → Create timeline.
2. Velitask computes the time window from the source and pulls in the intersecting render log entries and video sources.
3. The timeline editor tab opens — adjust the contents and export.

All your timelines are stored in the project; the list opens via Tools → Timelines.

Timeline List

The Tools → Timelines tab shows all timelines of the project.

• At the top — the Search field (filter by name), the Refresh button, and a "{n} records" counter.
• Table: Name, Start, Dur., Items (number of items), Created, Updated.
• Below the table — the Selected timeline block with details of the selected row: Output (export path), Items, Start, Duration, Canvas, Created, Notes, Updated.

Double-clicking a row opens the timeline. A right-click gives a menu:

Timeline Editor

Toolbar

Timeline Window

Two Tables

The window is split into two tables by a draggable divider (its position is remembered).

Video sources in window — the videos that fall into the window:

• the checkbox in a row (and the master toggle in the header) — include/exclude a video from the export;
• columns: preview, Name, Video time, Offset (offset from the start of the window), Dur., Track (track V1, V2…);
• the "separate tracks for video sources" toggle controls whether videos go into the export on separate tracks.

Render items in window — the renders (overlays) from the log that fall into the window:

• the checkbox in a row (and the master toggle in the header) — include/exclude an item;
• columns: preview, Indicator (the layer name; "— (whole mixel)" for a render of a whole composition; "🗑 record deleted" if the entry was deleted), Video time, Offset, Dur., Position, Size, Lane, Status (✓ everything in place, "⚠ file missing" no file, "🗑 record deleted" the entry was deleted).

Rows with a deleted source or a missing file are highlighted. At the bottom — a "{items} items · {videos} videos" counter.

Exporting a Timeline

1. Click Run export → — the Save timeline save dialog opens.
2. The format is determined by the file extension:

On the first export, a name with the .xml extension is suggested, and the XML (FCP7 xmeml) filter comes first. The last used format is remembered and offered first next time.

After export, the Open folder button opens the folder with the file.

XML (xmeml) is selected by default because DaVinci Resolve imports this format the most reliably — FCPXML has issues positioning clips whose resolution doesn't match the sequence resolution.

Importing into an Editing Application

After export, import the file into your editor (for example, in DaVinci: File → Import → Timeline). If the application reports that some clips are "not found" (offline), point it to the folder with the source videos — after that it will pull in the rest of the files itself. In DaVinci you can add source folders to Preferences → Media Storage once, and subsequent imports will link automatically.

Saving

A timeline (name, window, notes, the set of items and videos, tracks, and positions) is stored in the project. It is saved with Ctrl+S and automatically on export.

Related Pages

• Render Log — where timeline items come from.
• Video Export — render overlays and compositions.
• Supported Formats — details on the interchange formats.

Troubleshooting

• Clips are "offline" / not found in the editing application. This is standard behavior when importing interchange formats: point it to the folder with the source videos during import, or add it to Media Storage.
• A red "file missing" or "record deleted" row. The render was removed from the log or the file was moved. Re-render it from the render log and refresh the contents with the ⟲ Refresh button.
• FCPXML placed clips in the wrong spots. Use the XML (FCP7 xmeml) format — it is offered by default and imports more reliably.

Supported Formats

Velitask adds .mp4/.mov video, GPS tracks in GPX, images in the main raster formats, and .tmg telemetry to a project. Output: H.264 in MP4, QTRLE in MOV, images in PNG.

Video Input

Only two containers are added to a project (recognized by the scanner by extension):

Files in other containers (.avi, .mkv, .webm, .flv, .mpeg, .ts, .mts/AVCHD, and so on) will not be added to a project by Velitask — you must first re-save (remultiplex) them to .mp4 or .mov in any video editor.

Video Codecs

Decoding inside .mp4/.mov goes through FFmpeg (shipped as part of JavaCV). The set of supported codecs is determined entirely by the bundled FFmpeg build — the application does not validate or restrict it. Usually H.264 (AVC), H.265 (HEVC), VP8, VP9, AV1, ProRes, DNxHD, MJPEG, MPEG-2, and many others are available, but the exact list depends on the build version.

Audio Codecs

AAC, MP3, AC-3, Opus, Vorbis, PCM, FLAC.

Video Output

Velitask encodes through FFmpeg. Available:

The container is determined by the output file extension: .mp4 → H.264, .mov → QTRLE. There is no separate ProRes encoder in the current version: the "ProRes" item in the export dialog actually writes the same QTRLE-MOV (the distinction is kept only in the render log).

Output audio is always encoded to AAC. The "Copy" item means an attempt to carry the audio over without transcoding, but in the current export pipeline it is automatically converted to AAC, so in practice the audio in the output file is always AAC.

GPS Tracks

Additional GPX fields from Garmin (power, cadence, heart rate) are read.

Telemetry

Images

Maps

OpenStreetMap (256×256 tiles, URL template https://tile.openstreetmap.org/{z}/{x}/{y}.png). Alternative tile servers can be configured, but the standard distribution uses only OSM.

Mixel Templates

.vttp can be applied manually or placed into a templates folder so Velitask uses it as the default composition for new sources. Details: Mixel JSON and Templates.

Related Sections

• Importing Video, Importing GPX.
• Video Export, Image Export.
• Mixel JSON and Templates.
• Mixel Layouts in JSON.
• OSM Tiles.

Sensor Catalog

Sensors are data channels in a project. Velitask stores its own field set for each type. This section lists all supported types with measurement units and where they come from.

Why This Matters

When you choose a data source for a Mixel indicator or filter rows in Database Editor, you see the sensor type. This section is a reference for what to expect from each type.

Type Table

Velitask supports 14 sensor types. Each one is shown in the project tree under its own name.

The Watt type stores voltage and current (voltage / amperage), not a ready-made power value. The Electric type is a separate, fuller one: voltage, current, and power with deltas. Both types exist independently.

Atom Fields

Each atom is a record with a timestamp and values for the fields of its type. Common fields for all types:

Additional fields by type. The "Model fields" column lists everything stored in the project; the "Visible in Database Editor" column lists the columns actually shown in the table.

Measurement Units

The global unit-system choice (Settings → "Measurement units") applies to all indicators instantly:

Related Sections

• Sensor Telemetry — general concept.
• Importing GPX — the main source of sensors.
• Database Editor — where to view atoms.

Shortcuts

Summary of the main keyboard shortcuts in Velitask. On macOS, Cmd is used instead of Ctrl.

File and Project

Settings

Lists and Trees

Clearing Selection

Note

The exact set of shortcuts may differ slightly from version to version. If a shortcut does not work for you, check the hint next to the menu item (Velitask shows it in parentheses).

Playback (play/pause, jump to start and end, frame stepping) is easier to control with the player buttons: there are no corresponding shortcuts in the current version.

Related Sections

• Interface Overview — where to find each of these actions with the mouse.
• Mixel Editor.

Frequently Asked Questions (FAQ)

Short answers to the most common questions. If you do not find what you need here, see Troubleshooting.

Is Velitask free?

Yes. It is a desktop app downloaded from velitask.com.

What Data Does Velitask Send to the Internet?

Only requests for OSM tiles (the map). Projects, videos, and tracks themselves do not go anywhere; they are stored locally on your computer. Without internet, the app works except for downloading new map fragments.

Where Are Projects Stored?

In the folder you selected when creating the project. Inside it is the project database with metadata and sensors, as well as the video and GPX files themselves. Velitask accesses files by their path inside the project folder (the file name, and a nested subfolder if needed) — there are no links to external locations, so the files must reside in the project folder.

How Many Projects Can Be Open at the Same Time?

In the current version: one. To switch to another project, close the current one and open a new one.

Can Velitask Be Used for Cars / Boats / Paragliding / Running?

Yes. Conceptually it is not tied to cycling; any activity with a GPS track and video works. Some indicators, such as cadence, are cycling-specific, but they are optional.

What Is a Mixel?

In Velitask, Mixel is the final composition: a canvas with layers that you see in the player and get during export. Users work with the Mixel by adding layers and configuring their properties.

How Is a Plugin Different From an Indicator?

A plugin is an external module (.jar file) that brings a set of indicators. An indicator is a specific widget that you place as a layer into a Mixel. In other words, a plugin is the supplier, and an indicator is the catalog item.

Can I Work With Velitask Projects on macOS / Linux?

Velitask is officially supported only on Windows for now. macOS and Linux versions are planned; ready installers are not available yet.

What Happens to a Project If I Rename the Source Video File?

Velitask looks for the file by its saved name inside the project folder, so after renaming the source will stop opening. To restore it, give the file its previous name back in the project folder and re-scan the project — there is no separate UI for specifying a new path.

Can Velitask Edit Video (Cut, Join, Effects)?

No. Velitask creates overlays: indicators over video. Video editing is not its task. First cut/join the video in a video editor, then place the finished file into the Velitask project folder.

Can I Save a Mixel Template With Indicators and Apply It to New Projects?

Yes. Configure the Mixel in the editor, then choose File → Export → Template... and save .vttp. You can apply this template manually through Tools → Apply Template... or place it into a templates folder so Velitask uses it for new sources automatically. Details: Mixel JSON and Templates.

How Long Does Export Take?

It depends heavily on clip length, resolution, fps, and layer complexity. Roughly, exporting a 5-minute 1080p60 video with a typical indicator set on a modern CPU takes 5–15 minutes.

Can I Continue Export After an Error?

No. Export always starts from the beginning of the selected range. If it failed at 99%, you need to start again, but you can shorten the range.

Does Velitask Support Several Cameras at Once (Multicam)?

You can place several video layers in one Mixel, for example picture-in-picture. Full multicam editing with switching between cameras is not supported.

Where Can I Get Help If Something Does Not Work?

• Troubleshooting in this documentation.
• Logs: %USERPROFILE%\.velitask\logs\velitask.log.
• Project site velitask.com, which usually has contacts.

Troubleshooting

What to do when Velitask does not behave as expected. A list of symptoms, causes, and fixes. If none of the items below helps, collect logs (see the end) and contact support.

Velitask Does Not Start

Import

Time and Synchronization

See Time Synchronization for details.

Map

Mixel and Indicators

For template search and checking rules, see Mixel JSON and Templates.

Export

Performance

Logs

If none of the listed fixes helps, you will need the log:

• Log file: %USERPROFILE%\.velitask\logs\velitask.log.
• What it contains: chronological application events and errors.
• What to do: restart Velitask, repeat the problematic action, copy the fresh part of the log to a file, and send it to support.

Resetting Application Settings

If the application is clearly "broken" in terms of settings (theme, last and recent projects, panel state), it is important to know where these settings are stored:

• Interface settings (theme, last/recent projects, panel state, paths from "Files and Folders") are stored not in .velitask but in the system Java Preferences store. On Windows this is the registry under HKEY_CURRENT_USER (the com.velitask.desktop/1.0.0 node). A full reset of these settings is performed by the application itself with the Edit → Reset Preferences command (internally it calls VelitaskPrefs.resetPreferences()).
• The %USERPROFILE%\.velitask folder holds logs (logs/) and user resources, but not interface settings. Deleting it cleans up logs and resources, but does not reset the theme/last project.

# Clean up logs and user resources (does NOT reset the theme/last project):
Remove-Item -Recurse "$env:USERPROFILE\.velitask"

For a full reset of interface settings, use the reset command inside the application (Edit → Reset Preferences) — after it you may need to restart. Neither of these touches your projects — they are stored in the project folder you selected.

Related Sections

• Installation — requirements and installation problems.
• Interface Overview, Your First Project.
• Time Synchronization — the main source of confusing behavior.
• Supported Formats — if something does not open.
• Mixel JSON and Templates — if .vttp was not applied.
• Mixel Layouts in JSON — if a layer appeared in the wrong place.