Training Center XML — Garmin Training Format 2007: Activity/Lap/Track XML and Transition to FIT

Training Center XML (TCX) is an XML-based training-data format that Garmin introduced around 2007 for its desktop Garmin Training Center application. A file with extension .tcx and MIME type application/vnd.garmin.tcx+xml stores not just a GPS track but a complete workout: lap structure, heart rate, cadence, pace, per-point distance, plus optional extensions for speed and power. From 2007 to 2012, TCX was the primary format for Garmin Forerunner 305/310/405 and Garmin Edge 305/500/705 — USB export from those watches and bike computers returned .tcx. After 2012 Garmin moved to binary FIT, which is 5–10x more compact (a one-hour workout: 100 KB FIT vs 1 MB TCX), and TCX became legacy. But Strava, Garmin Connect, Endomondo (shut down 2020), TrainingPeaks, GoldenCheetah still accept TCX on import — so the format lives on in athlete archives as a "second life" for old training data.

History: Garmin Training Center and the Birth of TCX

In the mid-2000s, Garmin dominated the sports watch and bike computer segment: Forerunner 201 (2003), Forerunner 305 (2006), Edge 205/305 (2006) sold by the millions. Each device wrote training to internal memory, and the user had to somehow transfer data to a computer for analysis. Until 2007, Garmin offered Garmin Training Center (GTC) and its proprietary ANT binary sync protocol, but file exchange between devices and third-party software was painful — every program used its own format.

The answer was TCX — an XML schema published by Garmin in 2007 alongside a Training Center update. The intent paralleled GPX: an open standard, accessible to third parties, describing "everything you need for a workout" as a single XML. Unlike GPX, which describes geography (points, routes, tracks), TCX put structure first: a workout is split into laps, a lap into Track segments, a segment into Trackpoints. Each Lap carries statistics: time, distance, average HR, max HR, calories, intensity (active/resting), trigger method (manual/distance/location/time/heart-rate).

From 2007 to 2012, TCX was de facto the Garmin export format: Garmin Connect (launched 2008) returned workouts as .tcx, Strava (launched 2009) accepted only GPX and TCX in its early years, Endomondo and Runkeeper built their pipelines around TCX. Third-party sports watches — Polar, Suunto, TomTom — also added TCX export because Strava read TCX natively.

In 2010 Garmin introduced FIT (Flexible and Interoperable Data Transfer) — a binary format based on protocol buffers with variable-length fields, 5–10x more compact than TCX. With Forerunner 610 (2011) and Edge 800 (2010), Garmin moved to FIT as primary and kept TCX as an export option. By 2015, new Garmin devices wrote FIT only, and TCX survived only as a Connect export option for compatibility with older software.

Inside TCX: the Activity/Lap/Track/Trackpoint XML tree

TCX is XML in the namespace http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2. The root element <TrainingCenterDatabase> holds collections: <Activities> (recorded workouts), <Courses> (planned routes), <Workouts> (planned sessions), <Folders> (organization). In practice files from devices carry only <Activities>, and files from osm2cdr or route planners carry only <Courses>.

Hierarchy for a recorded workout:

<?xml version="1.0" encoding="UTF-8"?>
<TrainingCenterDatabase xmlns="http://www.garmin.com/xmlschemas/TrainingCenterDatabase/v2"
                         xmlns:ns3="http://www.garmin.com/xmlschemas/ActivityExtension/v2">
  <Activities>
    <Activity Sport="Biking">
      <Id>2026-05-12T09:15:00Z</Id>
      <Lap StartTime="2026-05-12T09:15:00Z">
        <TotalTimeSeconds>1842.5</TotalTimeSeconds>
        <DistanceMeters>12340</DistanceMeters>
        <Calories>412</Calories>
        <AverageHeartRateBpm><Value>142</Value></AverageHeartRateBpm>
        <Intensity>Active</Intensity>
        <Track>
          <Trackpoint>
            <Time>2026-05-12T09:15:02Z</Time>
            <Position>
              <LatitudeDegrees>48.8559</LatitudeDegrees>
              <LongitudeDegrees>2.3522</LongitudeDegrees>
            </Position>
            <AltitudeMeters>35.0</AltitudeMeters>
            <HeartRateBpm><Value>120</Value></HeartRateBpm>
            <Cadence>72</Cadence>
          </Trackpoint>
        </Track>
      </Lap>
    </Activity>
  </Activities>
</TrainingCenterDatabase>

Key elements. An Activity declares the sport via the Sport attribute: Running, Biking, Other. The <Id> is usually the UTC timestamp of the workout start. Each <Lap> is a separate split with its own statistics and a trigger method (how the lap ended: manual via Lap button, by distance, by location, by time, by heart-rate zone). Inside Lap comes <Track> (one or more segments — usually one) with a stream of <Trackpoint>.

A Trackpoint contains a required <Time> (ISO 8601 UTC) and optional blocks: <Position> (latitude and longitude as separate XML elements, in contrast to GPX attributes), <AltitudeMeters>, <DistanceMeters> (cumulative distance from lap start), <HeartRateBpm>, <Cadence> (rpm). Extensions through the ActivityExtension/v2 namespace add speed, power (Watts), RunCadence — data from power meters and foot pods.

Use Cases

A 2008 athlete looking back. A marathon runner trained for the Chicago Marathon in fall 2008 on a Forerunner 305. After every run, the device synced via USB and Garmin Training Center 3.6 — the program exported .tcx to a local folder. The files sat in an archive for 18 years. In 2026 the runner wants to re-open Strava and upload old workouts for history — Strava still accepts TCX, each upload takes 20 seconds and reconstructs full statistics: average pace, HR zones, lap splits. GPX would lose heart rate (Forerunner 305 wrote HR without extensions); TCX would not.

Importing a legacy activity into Strava in 2026. A cyclist bought a used Garmin Edge 705 (2008 vintage) for training without paid subscriptions. The Edge 705 writes TCX to internal memory and syncs via USB mass storage. Every week the rider plugs the device into a laptop, copies History/*.tcx, uploads to Strava via Upload Activity. Strava parses the TCX, treats Laps as splits, draws elevation profile and HR histogram. A device from 2008 still works in 2026 with no pipeline changes.

Workflow in OSM2CDR

Unlike GPX, which is often exported as "a district map for tourists," TCX in osm2cdr has one narrow role: preparing a planned route as a TCX Course for upload into Garmin Training Center or an older device. The scenario — a vintage-bike-computer enthusiast using Edge 305/705 wants a planned route through Paris Marais or Berlin Mitte loaded onto the device.

Pipeline: the user picks GPX in the Format Wizard on osm2cdr.ru, downloads a file with roads and trackpoints along the desired route. Then converts GPX into TCX via GPSBabel: gpsbabel -i gpx -f route.gpx -o gtrnctr -F route.tcx. The -o gtrnctr option writes TCX Course format (not Activity), suitable for Garmin Training Center → Send to Device. Alternatively, an XML template approach: take the exported GPX, run a Python script that converts it into a TCX <Courses> structure with <CoursePoint> blocks for turns.

osm2cdr also ships a direct tcx_exporter.py (format-id tcx, extension .tcx, ExporterType.LAYERS, MIME application/vnd.garmin.tcx+xml) — it reads linear PostGIS geometries as a Course Track, writes <TrainingCenterDatabase> with a single <Course> element and an inline <Track> of Trackpoints. POIs along the route become <CoursePoint> with types Generic, Left, Right, Summit — Garmin Training Center renders them with icons during navigation.

TCX vs FIT vs GPX

When to pick what. TCX — for legacy workflows only (old Garmin devices 2007–2012, importing archives into Strava). FIT — the native format of current Garmin watches and bike computers, 10x more compact than TCX; see FIT deep dive. GPX — universal exchange for hiking navigators and sports apps. For planning a route to a modern Garmin Edge — export GPX from osm2cdr; for backwards compatibility with an Edge 705 — convert GPX→TCX via GPSBabel. If you need navigatable POIs typed as Summit, Food, or Water, TCX Course with CoursePoint works better than GPX. Otherwise — GPX or FIT.

Related — modern OSM-based navigation in the Garmin ecosystem: see Garmin and OsmAnd and Garmin IMG for preparing a device basemap.

Conclusion

TCX is a snapshot of the 2007–2012 era in the sports industry: an open XML developed by Garmin as "GPX for workouts" with native support for laps, heart rate, cadence, and extensions for power. Two years after launch Garmin began transitioning to the binary FIT, and TCX turned legacy, yet the legacy is still alive: Strava, TrainingPeaks, GoldenCheetah accept .tcx on import, old Forerunner 305 and Edge 705 devices write only TCX, athlete archives hold millions of TCX files. On osm2cdr.ru, TCX support is in Course-format mode for preparing a planned route with embedded CoursePoint turn cues, ready to upload into Garmin Training Center or an older device by USB.

Ready to try? Open the Format Wizard, pick the format, get a TCX Course for your area in under a minute: /formats/tcx/.

Related Materials

• FIT — Garmin's binary format for watches and bike computers
• GPX — complete guide to GPS Exchange Format
• Garmin IMG — vector map format for Garmin devices
• Garmin and OsmAnd: OSM-based navigation

Sources

• Garmin, Training Center XML Schema v2 — garmin.com/xmlschemas/TrainingCenterDatabasev2.xsd
• Garmin Developer, ActivityExtension v2 — developer.garmin.com
• Strava Support, TCX file upload — support.strava.com
• GPSBabel, gtrnctr output format — gpsbabel.org/htmldoc-development/fmt_gtrnctr.html
• Wikipedia, Training Center XML — en.wikipedia.org/wiki/Training_Center_XML