Installation

Velitask for Windows can be installed from the MSI installer (recommended) or run from a ZIP archive without installation.

Why This Matters

Velitask is a desktop app for Windows. Distributions are bundled with Java Runtime (JRE 21), so you do not need to install Java separately. The two package formats cover the main scenarios: system installation with shortcuts through MSI, or 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 because 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 installation, the Velitask shortcut will appear in the Start menu, and Add or Remove Programs will include an uninstall entry.

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 Velitask.exe.

Velitask still creates its config and caches in the user profile. The ZIP folder itself stays clean.

Where Velitask Stores Its Data

The .velitask folder in the profile is created on first launch. Deleting this folder resets application settings, but does not touch your projects.

Uninstalling

• MSI installation: Settings → Apps → Velitask → Uninstall (or Programs and Features).
• ZIP launch: simply delete the extracted folder. To remove settings too, delete %USERPROFILE%\.velitask\.

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 Velitask.exe does nothing. Make sure you extracted the ZIP completely and are not running the app directly from the archive. Windows may also block the launch; in the file properties, check Unblock.
• The MSI installation requires administrator privileges, but 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 antivirus exclusions.
• It does not launch on Windows 7/8. These systems are not supported. The minimum is Windows 10 64-bit.

Interface Overview

The main Velitask window is divided into the menu, a left tool panel, the central Mixel player, and the status bar. This is enough to open a project, add a source, build a composition, and export the result.

Why This Matters

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

Main Menu

Left Panel (Tool Tabs)

On the left are switchable panels. Each can be closed with the cross and returned through View.

• Project (Sources) — the project tree: video, GPX tracks, images, OSM, sensors.
• Layers — the list of layers in the current Mixel: video, map, graphs, 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 corresponds to a particular frame.
• Tasks — the queue of background operations: GPX import, preview generation, export. Progress and errors are shown here.

Center Area: Mixel Player

In the center is the composition canvas (Mixel) with familiar video player controls:

• ▶ Play / ⏸ Pause, ⏮ Start / ⏭ End, ⬅ Prev frame / ➡ Next frame buttons.
• A timeline with the current position cursor.
• A preview of the video and overlaid indicators at the current moment.

The player shows the same content that will appear in the final exported video.

Status Bar

At the bottom of the window is a small strip with short information: the current background task and its progress, save messages, errors.

Startup Window

On first launch, a welcome window may appear with a Start working button and a Show on startup checkbox. Clear the checkbox if you want to go directly to the working window.

What to Do Next

1. Create a project: File → New Project… and choose a folder.
2. Drag video and a GPX track into the window, or add them through the menu.
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

This lets you quickly see the full Velitask cycle. All steps below use one 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.

Steps

1. Create a Project

1. Open Velitask.
2. File → New Project… (or Ctrl+N).
3. In the dialog, choose an empty folder, for example D:\Velitask\my-first-trip\. Velitask will create project files there (database, metadata).
4. Velitask takes the project name from the folder name.

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

2. Add Video

1. Drag a .mp4 file (or .mov, .mkv, .avi) directly into the Velitask window. Alternatively, use File → Import… or the context menu in the source tree.
2. Velitask will add a node like Video → my-clip.mp4 to the tree and automatically read metadata (duration, resolution, fps, shooting date).
3. The frame analysis progress will appear in background tasks (the Tasks tab).

3. Add a GPX Track

1. Drag .gpx into the window. Velitask recognizes GPX automatically.
2. A GPX → my-track.gpx node will appear 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. You will see the import on the Tasks tab. Wait until it finishes; large GPX files can take 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 one Profile for each source. Open the camera profile:
   • Time zone — set the time zone that the camera clock used, for example Europe/Moscow.
   • Offset, sec. — leave 0 if the clock was accurate. If it was wrong (the camera was one minute fast), enter the correction here.
3. Do the same for the GPX source profile. Most GPS devices already record the track 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, speed text, time text, map, distance, and so on.
2. Drag the indicator you need onto the player canvas in the center, for example Speed text.
3. The right panel will show layer properties: position, size, source binding. Link the indicator to the GPX speed sensor.
4. In the same way, add Time text (clock) and GeoMap (mini map), a typical set for a cycling ride.

See Mixel Editor for details.

6. Preview the Result

1. Click Play (▶). Velitask will play the video with overlaid indicators.
2. Scrub the timeline cursor and check that speed, distance, and 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….
2. Choose the range (the entire Mixel by default), quality preset, codec (H.264 is the most compatible), fps, and audio.
3. Specify the output path, for example D:\Velitask\my-first-trip\export.mp4.
4. Click Start. Progress is shown on the Tasks tab.
5. When finished, the ready file will appear in the selected 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/FIT when they are present.
• Adjust indicator settings: size, color, position.
• Save an export preset to quickly reuse the same encoding settings in future projects.

Related Sections

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

Time Model

Inside a project, all time is stored in UTC. Each source device (camera, GPS logger, bike computer) is converted to UTC through a Device Profile: the pair of time zone + clock offset.

Why This Matters

Video, GPX tracks, and sensor records carry time in different ways. One camera may be set to Europe/Moscow, another device may be in UTC, a third clock may be one minute fast, while a GPX receiver usually writes UTC all the time. If everything is simply combined as is, speed and distance values will appear at the wrong moment.

Velitask solves this as follows:

1. Every source has raw timestamps: what the device recorded.
2. A Device Profile converts them to UTC.
3. The internal project scale lives in UTC: the Mixel timeline, indicators, and export.

The user does not manually enter UTC anywhere. You only say: this camera used this time zone and was fast or slow by this many seconds.

Device Profile

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

By default, Velitask creates one Profile for each source. Profiles are listed and edited on the Devices tab.

Profile Inheritance

To avoid setting a Profile on every source separately, inheritance rules are used:

1. Each source has its own Profile: priority 1.
2. If the source has no Profile, the Profile of the folder containing it is used.
3. If that is also missing, the project root Profile is used.
4. If nothing is set anywhere, UTC with offset 0 is used.

This makes it 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) + correction

• raw — what the device recorded.
• tz_offset(raw) — the time zone offset from UTC at that moment (including daylight-saving changes).
• correction — the user clock correction in seconds.

Velitask works in both directions: it stores UTC and can show device-local time too, 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 clock offset. Cameras are often 5–60 seconds off compared to the reference. These seconds are set through the Profile offset.
• GPX is almost always in UTC. If the GPX file explicitly uses UTC, which is the typical case, UTC and 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 graph. All of these are layers of one composition. A Mixel is the container that stores and plays them.

A project usually has one Mixel: the main composition. But a Mixel is not rigidly tied down. Later, you may have separate Mixels for different parts of a route or different export variants.

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 layer types:

Most layers are indicators from a plugin (see Indicators and Plugins). This means the list of layers is extensible: installing a new plugin adds new types to the Mixel.

Binding a Layer to a Source

Data layers (Speed, Distance, GeoMap, and so on) show values from a specific sensor of a specific source. This binding is explicit:

• The layer properties in the right panel include a Source field, or several fields if the indicator uses multiple channels.
• Velitask does not guess the source for you. You choose “take this speed from the GPX track morning-ride.gpx”, and the layer works only with that data.
• If no source is set, the layer will show 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, which 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, while opening a GPX track with a full-canvas map.

Velitask can apply these 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 and thumbnail-gpx.vttp.

Details: Mixel JSON and Templates. For layer placement in a template, see 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 layers, and configure them in the properties panel. But templates are useful when:

• 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 adjust basic values in JSON;
• 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, 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 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.

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 source bindings.
5. Save the project if the result is correct.

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

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 it builds candidate file names:

For each name, levels are checked in this order:

Priority:

1. More specific names win first: ride.vttp is stronger than mp4.vttp, and mp4.vttp is stronger than video.vttp.
2. Within one name, the project template is stronger than the user template.
3. The user template is stronger than 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 are checked only at their top level for default templates. If you put video.vttp into a nested folder inside the user templates folder, automatic search will not see it.

Project, User, and System Templates

A project template is useful when one project needs 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 useful for your 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. Do not 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.

Current names:

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 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" }
      }
    }
  ]
}

Important fields:

• 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, see 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 settings of the specific indicator. In this example, fitTrack makes the map fit the track.

What Is Safe to Edit Manually

Safest changes:

• change the placement preset if you understand the difference between fill and auto;
• change simple properties with clear values, such as true / false, numbers, or colors;
• remove an unnecessary layer from layers;
• 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:

• name — if the indicator is not installed, 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, or similar ids from one project to another. In the new project, those ids may point to different data or not exist at all.

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 unexpectedly, temporarily remove it from the templates folder and open the source again.

Troubleshooting

Related Sections

• Mixel and Layers — 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. Velitask templates support 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 in 1920x1080, but shift or become too small in vertical video, square video, or 4K.

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

• fill the parent completely;
• let the indicator choose its default 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 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, exact JSON values are used.
3. If this is a template and there is no maket, size, or position, auto is applied.

Practical result: 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. Exact pixel fields may 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 used, Velitask cannot apply that maket. If size and positionInParent are present, they are used instead. 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 asks its indicator for default placement.

For official indicators, default placement is defined by the indicator itself:

These values are a starting layout. You can still move and resize the layer in the editor afterwards.

Choose auto when:

• you want the indicator's standard placement;
• exact position is not important;
• 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 symmetrical;
• the template must look the same across projects;
• you want a specific percentage width and height.

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

fill

fill looks like this:

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

It does one simple thing:

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

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

Good scenarios:

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

Example:

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

If you want margins around the edges, fill is not enough. 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
  }
}

Fields mean:

Values are usually 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 usually it is a mistake.

If fields are omitted, defaults are used:

So this JSON:

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

is equivalent to a layer filling the parent:

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

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

Ready-Made Formulas

Top-Right Corner

The layer takes 22% width, 30% height, with 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 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. Use carefully: part of the layer will be outside the canvas.

maket, size, and positionInParent

A regular saved Mixel may store exact pixel fields:

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

For templates, this is less convenient because 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 size and position. If there is no maket, Velitask tries to use size and positionInParent.

What Happens When Mixel Size Changes

When the Mixel canvas size changes, Velitask reapplies 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 default placement again.

This is why proportional works well for templates that need to 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.

If the layer already has an active maket, its preset is saved:

• auto is saved as { "preset": "auto" };
• fill is saved as { "preset": "fill" };
• proportional is saved with calculated x, y, w, and h.

If the layer has no active maket, Velitask saves it as proportional by default: it takes the current pixel coordinates and divides them by the parent size.

Practical tip: after exporting a template, open .vttp and check that the layers you want to control use preset: "proportional" with understandable x, y, w, and h.

Choosing 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 — general .vttp format and template search rules.
• Mixel and Layers — the basic layer model.
• Mixel Editor — visual layer configuration.
• Supported Formats — where .vttp is listed.

Indicators and Plugins

An indicator is a widget over the video: speedometer, speed text, mini map, slope graph. 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 or track recording, and then plugins add more: indicators for paragliding, boats, cars, custom graphs, and so on.

What a Plugin Is

A plugin is a module that brings:

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

A plugin does not change the application core, access the project database, or replace existing indicators. It only adds new items to the catalog.

Where Indicators Are Visible

Standard Set (Velitask Plugin)

The list may grow from version to version. Check the Indicators tab after updates.

Installing Additional Plugins

In the current Velitask version, plugins are delivered as separate .jar files. Installation:

1. Close Velitask.
2. Put the .jar into the plugins folder: %USERPROFILE%\.velitask\plugins\ (create the folder if it does not exist).
3. Start Velitask. The new indicator will appear on the Indicators tab.

If the plugin does not appear, check the application log (%USERPROFILE%\.velitask\logs\velitask.log). It shows whether the file was loaded successfully.

Indicator Skins

A skin is a named set of visual 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 good.

Skin Sources

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

For example, the Video indicator has built-in skins: framed (with a white frame) and rounded (with rounded corners and no frame). The speedometer has Default, Night, and Racing.

The Default Skin Is Applied Automatically

When you add a new layer to a Mixel, Velitask automatically applies the first built-in skin. That means:

• When you drag the Video indicator onto the canvas, its parameters are immediately set as in the framed skin: opacity 100, white frame, no rounding.
• When you drag Speedometer, it gets parameters from the Default skin (branded colors).

This makes the indicator look normal immediately instead of like a raw technical placeholder. After that, you can keep it as is, switch to another skin, or manually adjust individual properties.

When opening an existing project, the previously selected indicator skins are 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 found 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; the skin 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 just like built-in skins.

.vtskin Files

.vtskin is a small JSON file that stores one or more of your skins for different indicators. It is useful because:

• Moving between projects. Copy .vtskin into another project folder, and Velitask will find it and show it in the Skin menu for matching indicators.
• Sharing with colleagues. You can send the file, 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 graph skins: a whole style 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 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 bring someone else’s sources with it.

When the Skin Menu Does Not Appear

The Skin submenu is visible only for indicators whose author declared skins for them in the plugin. Some standard and custom indicators may have no skins; in that case, 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, so it understands almost any format from action cameras and smartphones: MP4, MOV, AVI, MKV, WebM, and others. Import is done by dragging a file into the window or through File → Import.

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, fps, and shooting date from metadata when available.

Files Velitask Understands

FFmpeg works under the hood, so the list of formats is very broad:

Even uncommon formats like .MTS (AVCHD) or .gp usually open. If something does not open, it is usually a damaged file. A fallback is to resave it through any video editor and try again.

How to Add Video to a Project

Method 1. Drag-and-Drop

1. Open File Explorer with the file you need.
2. Drag .mp4 (or another video file) directly into the Velitask window: onto the source tree or the player canvas.
3. A Video → file-name node will appear in the tree. Velitask starts reading metadata in the background (the Tasks tab).

Method 2. Through the Menu

1. File → Import…
2. In the dialog, choose the video file.
3. Velitask adds it to the project just like drag-and-drop.

Method 3. Several Files at Once

Drag several files at once. Velitask adds each as a separate source.

What Happens After Import

1. Metadata reading. Duration, resolution, fps, codec, shooting date (if EXIF/metadata are present in the file).
2. Device Profile creation. Velitask adds a new Profile to the tree or links to an existing one from filename hints (for example, the camera series). The default time zone comes from the parent folder 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.

During import, the file itself is not copied into the project folder: Velitask stores a link to the source path. Do not move or delete the video 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 layer properties, select your video source.

See Mixel Editor for details.

Audio

The audio track is read, available in the player when enabled, and included in export. By default, audio is copied without transcoding; in export settings, you can transcode it to AAC.

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. If it is missing, Velitask uses the file modification date; 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. Import is done by drag-and-drop or through the menu. Large tracks are imported 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, altitude, slope. Indicators over video usually work from GPX data.

What Velitask Does With GPX

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

If GPX contains additional fields (power from a bike computer, cadence, heart rate), they will become their own sensors: Watt, Cadence, Pulse, Meteo, and so on.

Import

Method 1. Drag-and-Drop

Drag .gpx into the Velitask window: onto the source tree or directly onto the canvas. Velitask recognizes the extension and starts import immediately.

Method 2. Through the Menu

File → Import… → choose .gpx.

What Happens Next

1. A GPX → your-track.gpx node appears in the tree. Inside it is a list of sensors (Geo, Distance, Elevation, Speed, Slope, and so on).
2. Progress is visible on the Tasks tab. Very large tracks (tens of thousands of points) take noticeably longer to import.
3. After completion, sensors are available for binding to Mixel indicators.

Time in GPX

The GPX standard recommends UTC. Most devices write it that way, and Velitask keeps the time as is.

During import, Velitask creates a Device Profile for the GPX source. By default it inherits the parent folder Profile, but in most cases the correct GPX Profile is UTC, offset 0. 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. Points have identical timestamps, or no timestamps at all. Velitask cannot calculate speed. 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 timestamps).

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 know 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 its sensors.
3. Double-click a sensor to open 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 or hundreds of thousands of atoms. The database handles this normally; the Database Editor uses paged display for viewing.

Raw and Processed Values

Velitask does not clean up sensor data for you. What was recorded is what is stored. If a GPX track contains speed spikes, for example 200 km/h on a bicycle because of a GPS glitch, they will enter the sensor as is, and the indicator will show them too.

What you can do about this:

• Edit atoms manually through Database Editor: replace or delete peak values.
• Use 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 during export, and gentle on OSM servers for every frame, tiles are cached locally.

How It Works

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

Where the Cache Is Stored

%USERPROFILE%\.velitask\osm-cache\

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 used projects in many regions.

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

Offline Work

If you render the map for the needed region and 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 GeoMap 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: it limits parallel downloads, caches tiles, and does not download the same tile repeatedly.

If you plan very intensive map work, the tile source can be changed in the map settings.

What Is Shown on the Map

The map itself is just the background. The GeoMap indicator draws over it:

• Track — a line through Geo sensor points.
• Current position marker — at the location corresponding to the Mixel cursor UTC time.
• Optional direction and current point information, depending on indicator settings.

Related Sections

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

Troubleshooting

• The map is gray and tiles do not load. Check internet access. If you are behind a proxy, Velitask has no built-in proxy setting and relies on the system configuration.
• The map works, but there is a hole in one place. The cache for these tiles is damaged. Delete the corresponding subfolder in osm-cache or the whole cache.
• The cache takes a lot of space. This is normal for active users. Delete the entire osm-cache folder; Velitask will recreate it as needed.
• Tiles look blurry. You are viewing the map at a zoom level whose proper tiles have not been loaded yet. Scroll or change zoom; Velitask will load the needed tiles.

Sources Panel

The left Project tab is the tree of all project sources and sensors. Here you add, delete, group, rename data, and double-clicking a node opens the corresponding editor.

Why This Matters

Velitask stores all project data (video, GPX, images) as sources in one tree. From this tree, you can:

• see everything in the project in one place;
• group sources into folders, for example by trip day;
• quickly open data for viewing and editing;
• drag sources directly into the Mixel to create a layer.

How the Tree Is Organized

Tree nodes:

Nodes have their own icons by type.

What You Can Do in the Tree

Cards and Hints

Sources show additional indicators:

• Import status check/icon (whether sensor data is already in the database).
• Progress indicator for sources currently being imported.
• Icon of the Device Profile bound to the source.

Source Context Menu

Right-clicking a source opens a menu with typical actions:

• Open — same as double-click.
• Rename.
• Bind Device Profile… — choose or create a time Profile.
• Create layer in Mixel — quickly insert it as a layer.
• Show in DB — open Database Editor for sensor sources.
• Delete — remove from the project.

Related Sections

• Importing Video, Importing GPX — how to populate the tree.
• Sensor Telemetry — about sensors inside sources.
• Mixel Editor — where to drag a source.
• 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 that convert raw time to UTC.

See Time Model for the theory.

Where and What to Configure

All Profiles are on the Devices tab in the left panel. Each Profile is a separate card.

Typical Configurations

Action-Camera Video

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

• Which time zone was the camera set to? Use this 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. Difference in seconds means you adjust offset. 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 through the parent folder. Then editing the Profile in one card affects all clips.

Synchronization Scenario

1. Import video and GPX (see Your First Project).
2. Open Devices. Velitask automatically created one Profile per source.
3. For GPX, keep UTC, offset 0.
4. For video:
   • Set the camera time zone (the one its clock used during shooting).
   • Keep offset as 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 N as the video Profile offset. Sign: if the video is “late” compared to GPX, the offset is positive.
8. Confirm the change and check again. Adjust if needed.

Group Synchronization

After one camera Profile is configured, copy it to other cameras of the same model by binding it to a shared folder.

Checking After Edits

• Move the cursor to different parts of the timeline and make sure 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 offset 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; this is 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

From the Indicator Catalog

1. Open the Indicators tab.
2. Find the indicator you need, for example Speed text.
3. Drag it onto the canvas or into the Layers list.
4. Velitask creates the layer and opens its properties on the right.

From the Source Tree

1. Open the Project tab.
2. Drag a video or sensor directly onto the canvas.
3. Velitask chooses a suitable indicator type by itself (Video for video, Speed text for speed, and so on) and immediately links it to the source.

Through the Context Menu

Right-click the canvas or layer list → Add… → choose an indicator.

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, Speed text is linked to one speed sensor.
• Some indicators can accept several sensors, for example GeoMap + 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 with drag-and-drop.
• Resize using corner or edge handles.
• Enter exact values in properties.
• Enable anchor binding, for example “to the bottom-right corner of the canvas with a 24 px margin”.

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.

Grouping

Several layers can be combined into a Group. A group moves and scales as one unit, while the relative placement inside it is preserved. This is useful for keeping together a background + text + icon, for example a “distance card”.

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, properties, and indicator settings are written to the project database. There is no separate Save Mixel button: changes are saved automatically.

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

Database Editor is a table view of project sensor atoms. It opens for a sensor, shows rows with timestamps and values, and allows navigation, filtering, and editing.

Why This Matters

Most users work with sensors through indicators and do not 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, remove an erroneous record, or see when a GPX track changed from movement to stop.

The Database Editor is the project tool for all of this.

How to Open

• Double-click a sensor in the source tree.
• Sensor context menu → Open in DB.
• Tools → Database Editor → choose sensor.

A window/tab with a table opens.

Main Window Elements

Table Columns

Columns depend on sensor type. Common to all:

Additional columns by type:

See Sensor Catalog for details.

What You Can Do

Saving Changes

Changes made in Database Editor are saved automatically to the project database. You can undo through the project-wide Undo if your version supports it, or manually edit again.

Warning: deleted atoms can be restored only by reimporting the source file. Make important edits on a project copy.

Related Sections

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

Sensor Row Editor

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 Database Editor shows it in a table. But sometimes you want to see exactly what the Mixel will show at that instant. For example:

• Correct an erroneous value and immediately check how it looks in the frame.
• Understand which track point a specific atom corresponds to.
• Check that an imported atom really matches a video fragment.

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

How to Open

• Double-click a row in Database Editor.
• From the context menu in the DB editor.

A window opens with two halves:

• Left: a form with atom fields (Time, value, and so on).
• Right: Mixel preview at the atom time.

What Is Inside

Left Half: Atom Form

• Fields by sensor type (for example, lat/lon for coordinates, power value for Watt).
• time field: UTC timestamp.
• ← Prev / Next → navigation buttons: move to neighboring atoms of the same sensor by time.
• Save button is active when there are unsaved changes. You can enable the Auto-save checkbox; edits will then be saved automatically after a delay.

Right Half: Mixel Preview

• Canvas with the same layers as the project main Mixel, or a simplified set depending on preview settings.
• Time slider, which lets you play with the cursor position near the atom.

“Copy Main Mixel”

The right half has a Copy main Mixel button. It replaces the preview Mixel with a copy of the main one. This is useful when you want to see the atom in the context of the full composition instead of a simplified preview scheme.

Typical Scenario

1. In Database Editor, you find a suspicious atom, for example speed 200 km/h.
2. Double-click it to open Sensor Row Editor.
3. In the right preview, you see the corresponding frame and indicators.
4. You see that the bicycle is standing still on the video, but the indicator still shows 200 km/h: a GPS spike.
5. Edit the value in the form on the left and click Save, or wait for Auto-save.
6. The preview updates, and the indicator shows the corrected value.
7. Use ←/→ to move to neighboring atoms and check the surrounding data.

Related Sections

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

Video Export

The finished Mixel is saved to a video file through File → Export → Video…. H.264 (MP4), QTRLE, and ProRes (MOV) are supported. 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: 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…
3. A settings dialog appears.
4. Fill in the parameters (see below) and click Start.
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 one ride from the entire project.

Codec and Container

Resolution and FPS

• Resolution — presets (low / medium / high) or custom resolution. For most codecs, it should be divisible by 2.
• FPS — frames per second. Common values: 25, 30, 50, 60. The maximum is usually limited by the source video fps.

Higher resolution and fps make export slower and the file larger.

Audio

How Export Works

1. Velitask walks the timeline from Start to End 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 source video and transcoded if needed.
5. Finished frames and audio are packed into the container (MP4 or MOV).

Export speed depends on:

• Resolution and fps.
• 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 Audio is not set to None. If Copy is selected but there is still no audio, the source audio codec may be incompatible with MP4. Choose AAC.
• The file size is very large. You probably selected QTRLE or ProRes. This is normal for master codecs. Use H.264-MP4 for sharing or publishing.
• Export takes too long. Lower the resolution or fps. 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 or JPG 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 dialog, specify:
   • File — output path and file name. The extension determines the format (.png / .jpg).
   • Resolution — keep the Mixel resolution or specify your own.
4. Click Save.

The file is created instantly. A background task in Tasks usually does not start because the amount of work is small.

Formats

Related Sections

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

Video Export Presets

A video export preset is a saved set of parameters from the File → Export → Video dialog: codec, resolution, fps, audio. Configure it once and use it in every project.

Why This Matters

Export parameters are usually the same for many videos: “H.264, 1080p60, AAC”. Filling the dialog again every time is unnecessary work. A preset saves these parameters under a name and applies them with one button.

Do not confuse video 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 composition templates, see Mixel JSON and Templates.

How to Use It

How to Create a Preset

1. Open File → Export → Video…
2. Configure all parameters as needed.
3. In the dialog, find Save preset (or the floppy disk icon).
4. Enter a preset name: “YouTube 1080p”, “Master ProRes”, “Instagram 1:1”.
5. Confirm.

The preset is saved in Velitask settings and is available from any project.

How to Apply a Preset

1. Open the export dialog.
2. At the top, choose the needed value in the Preset dropdown.
3. All fields are filled according to the saved parameters.
4. Adjust the settings for this specific export if needed, for example the range.
5. Click Start.

What Is Included in a Preset

So a preset is about how to encode, not “what to export and where to save the file”.

When Several Presets Are Useful

Related Sections

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

Supported Formats

Velitask reads almost any video through FFmpeg, GPS tracks in GPX, and images in the main raster formats. Output: H.264 in MP4, QTRLE and ProRes in MOV, images in PNG/JPG.

Video Input

FFmpeg works under the hood, so the list is very broad. Real limitations are mostly damaged or unusual files.

Containers

Video Codecs

H.264 (AVC), H.265 (HEVC), VP8, VP9, AV1 (if supported by your FFmpeg build), ProRes, DNxHD, MJPEG, MPEG-2, and dozens of less common codecs.

Audio Codecs

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

Video Output

Velitask encodes through FFmpeg. Available:

Output audio:

• Copy — without transcoding (fast, lossless).
• AAC — MP4 standard.

GPS Tracks

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

Images

Maps

OpenStreetMap (256×256 tiles). 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 origins.

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

Atom Fields

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

Additional fields by type:

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

Import and Export

Playback

Mixel Layers

General

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), or look in View → Keymap if your version has that item.

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. Video and GPX files themselves are not copied; Velitask stores links to the original files.

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 loses the link to that file. An indicator “file not found” appears next to the node in the source tree. You can restore the link by opening the source properties and specifying the 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 import the finished file into Velitask.

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 settings are clearly broken (theme, last project, cache), you can reset them:

Remove-Item -Recurse "$env:USERPROFILE\.velitask"

After that, Velitask starts from a clean state. This does not touch your projects: they are stored in the project folder you selected, not in .velitask.

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.