Workouts: A GNOME Desktop App to Plan, Track and Review Your Strength Training

Table of Contents

1. Key Highlights
2. Introduction
3. What Workouts Does and Who It Serves
4. Core Features Explained
5. How a Typical Session Flows
6. Example Workouts: Templates and Practical Use Cases
7. Creating Effective Workout Plans in Workouts
8. Timed Holds and Supersets: Why They Matter
9. Installation and Setup: What to Expect
10. Technical Foundations: Python, PyGObject and GTK4
11. Data Storage, Privacy and Portability
12. Integration with Other Tools and Wearables
13. Accessibility and GNOME Integration
14. Contributing and the Development Community
15. Scenario: A Real-World Use — Planning a 12-Week Strength Cycle
16. Best Practices for Logging Accurate Training Data
17. Limitations and Where Workouts May Not Fit
18. How to Get the Most from Workouts
19. Comparing Workouts to Alternatives
20. Practical Walkthrough: Building a Sample Workout in Workouts
21. Security Considerations
22. Roadmap Ideas and Potential Improvements
23. Troubleshooting Checklist
24. Real-World Example: Using Workouts for Coach-Client Sessions
25. Community and Next Steps
26. FAQ

Key Highlights

• Workouts is a free, open-source GNOME application for creating structured workout plans, logging sets and timed holds, and reviewing training history.
• Built with Python, PyGObject and GTK4, it supports supersets, per-set reps/weight/rest logging, and offers a countdown for timed exercises; source code and releases are available on GitHub under GPLv3.

Introduction

A workout app that lives on the desktop rather than on a phone changes how some people approach training. Workouts places planning, execution guidance, and historical tracking inside the GNOME environment, letting users design routines, record weights and repetitions, and review completed sessions without handing their data to a third-party service. The application focuses on practical features athletes and hobbyists need: sets, reps, rest timers, supersets, and timed holds. Because it is free and open source, users can inspect the code, request features, and contribute fixes.

This article examines what Workouts offers, how it works for different training styles, how to install and set it up, and how to get the most out of it. It also explains the technical choices behind the app and outlines realistic use cases and limitations. Whether you train with barbells, bodyweight drills, or rehabilitation holds, the following guide shows how Workouts can fit into your routine.

What Workouts Does and Who It Serves

Workouts targets people who want a focused desktop tool for planning and tracking exercise sessions. It is particularly relevant to:

• Strength trainees who prefer a desktop interface for creating structured programs (e.g., 5x5, push/pull/legs).
• Home gym users who log weights and repetition counts and want simple rest and set tracking.
• Users who perform timed isometric exercises—planks, holds, wall-sits—and need a clear countdown during each set.
• Individuals concerned with data ownership and privacy who favor an offline, open-source solution over cloud-based fitness apps.

The app does not seek to replace deep analytics platforms or wearable ecosystems. Instead, it provides a compact, integrated environment for session planning and record-keeping that fits naturally on GNOME desktops. Its feature set aligns with the needs of everyday trainers: creating and managing workout plans, logging per-set metrics (reps, weight, rest), supporting supersets, timed holds, and presenting a training history for progress review.

Core Features Explained

Workouts packs a focused set of features that match the workflows of many trainees. Each feature is designed to simplify planning and execution without adding unnecessary complexity.

• Create and manage workout plans with exercises and sets
  • Users can compose routines that include specific exercises, set counts, and structure. This enables programs such as strength cycles, hypertrophy splits, or circuit templates.
• Log repetitions, weight and rest times during workout sessions
  • During a session, each set can record the number of reps completed, the weight used, and the rest taken between sets. This data provides a clear record for future sessions and progression.
• Superset support
  • Supersets—pairing two or more exercises back-to-back—are supported so users can model push/pull pairings or antagonist supersets without breaking the flow of a session.
• Timed hold exercises with a countdown
  • Isometric holds often require precise timing. Workouts includes a countdown timer for these exercises, keeping attention on the hold rather than on watching a clock.
• Training history view
  • Completed sessions are stored and presented so users can review past workouts, spotting trends in load, rep ranges, and consistency.

Together, these features provide a reliable skeleton for planning and monitoring most gym and home workouts.

How a Typical Session Flows

Understanding the user flow clarifies how Workouts fits into training routines.

1. Build a plan: Create a new workout plan and add exercises. For each exercise you set the number of sets and the type (regular or timed hold). You can group exercises to form supersets where required.
2. Start the session: Load the plan for the day and begin the workout. The interface guides you through sets and shows the active exercise, set count, and any countdown for timed holds.
3. Log each set: After performing a set, record the reps and weight used, and optionally the rest time. If you skip a set or change weight, adjust values before proceeding.
4. Track supersets: For paired exercises, the app advances to the next exercise in the superset sequence without presenting redundant navigation steps.
5. Finish and review: When the session ends, the app records the completed workout in the training history. Users can later open past sessions to inspect exact set-by-set details.

This workflow mirrors the activities most lifters already perform mentally or on paper, but consolidates them into a single desktop location with timestamps and consistent formatting.

Example Workouts: Templates and Practical Use Cases

Concrete examples show how Workouts can be applied to different training needs.

Example 1 — Strength-focused barbell session (5x5)

• Plan: Squat 5x5, Bench Press 5x5, Bent-over Row 5x5
• How Workouts helps: Define each exercise with 5 sets. Log weights and reps for each set, track rest times between heavy sets, and use the training history to ensure progressive overload across sessions.

Example 2 — Hypertrophy upper/lower split

• Plan: Upper Day — Bench Press 4x8, Incline Dumbbell Press 3x12, Lat Pulldown 4x10, Face Pull 3x15
• How Workouts helps: Create a template with varied rep ranges. Record RPE or subjective notes in the session (if supported in the app or as meta notes) to guide load adjustments the next week.

Example 3 — Bodyweight circuit for home training

• Plan: Circuit of Push-ups 3xAMRAP, Bodyweight Rows 3xAMRAP, Bulgarian Split Squats 3x10/leg, Plank timed holds 3x60s
• How Workouts helps: Using supersets or circuit groups streamlines moving between exercises; timed holds use the countdown to enforce consistent durations.

Example 4 — Rehabilitation/isolation with timed holds

• Plan: Shoulder external rotation holds 3x30s, scapular retractions 3x20s
• How Workouts helps: Time-driven exercises keep holds uniform and reduce the cognitive load on the rehabilitation patient, improving compliance.

These examples show how the app can represent classic training structures. Workouts is particularly suitable when the priority is accurate, per-set logging and simple timers rather than analytics-driven coaching features.

Creating Effective Workout Plans in Workouts

Designing an effective plan requires thought beyond simply listing exercises. The app provides the skeleton; programming quality remains with the user.

• Establish clear goals per cycle: Strength, hypertrophy, endurance, or rehabilitation. Each goal implies different rep ranges and progression rules.
• Organize exercise order logically: Compound lifts before isolation, larger muscle groups before smaller, and unilateral work where balance is a concern.
• Use supersets strategically: Superset an antagonist pair (bench then row) to save time and maintain training density, or superset accessory work to increase metabolic stress.
• Track rest intentionally: Rest length affects the outcome—long rests favor strength, moderate rests favor hypertrophy. Log rest durations to keep sessions consistent.
• Progress systematically: Increase weight, reps, or reduce rest week to week. Use the training history to verify incremental improvements.

A Workouts plan should reflect these principles: define sets, rep targets or timed goals, and place exercises into meaningful groups. The app simplifies the administrative burden so users can focus on progressive, consistent training.

Timed Holds and Supersets: Why They Matter

Timed holds and supersets are built into Workouts because both are common, effective tools.

Timed holds

• Isometric holds build endurance and stability in targeted positions. Planks, wall-sits, and pause squats are all examples.
• A countdown removes guesswork. Consistent durations improve training fidelity, which is especially useful in rehabilitation scenarios where adherence to specific times is important.

Supersets

• Supersets reduce session length by pairing exercises with little rest between them. That can raise intensity and metabolic stress, useful for hypertrophy or time-constrained workouts.
• Pairing antagonists (e.g., chest and back) can preserve performance while keeping density high. Pairing similar muscle groups creates a higher local workload and fatigue, which has a different training effect.

Workouts supports both constructs, so users can encode these strategies directly into their session templates.

Installation and Setup: What to Expect

Workouts is hosted on GitHub (github.com/AronCalvert/workouts). As a Python application that uses PyGObject and GTK4, it depends on the typical stack used by GNOME desktop applications. Installation options depend on how the project is packaged by the maintainer or by the community.

• Check the GitHub repository for releases and installation instructions. The README typically provides platform-specific steps and lists dependencies.
• Look for distribution packages. Some Linux distributions or community members may package Workouts for the native package manager (APT, DNF, Pacman). Search your distro’s repositories or community package sources.
• Search Flathub. Many GNOME applications are distributed as Flatpaks on Flathub. If a Flatpak is available, it offers a simple installation route that isolates the app and ensures runtime dependencies (GTK4, GNOME libraries) are available.
• Building from source. If a packaged release is not available, cloning the repository and following the developer documentation is the typical path. Expect to need Python 3.x, PyGObject bindings, GTK4 runtime libraries, and any other libraries listed in the project’s requirements. The project’s README will provide exact commands.

Because Workouts is a desktop GTK4 app, macOS and Windows support is not guaranteed unless explicitly added by contributors. GNOME and Linux are the primary target platforms.

Technical Foundations: Python, PyGObject and GTK4

The choice of Python, PyGObject, and GTK4 shapes the application’s behavior and user experience.

• Python: Enables rapid development and readability. It lowers the barrier for community contributions because many developers know Python and can review and extend the codebase.
• PyGObject: Provides Python bindings for GNOME libraries, making it possible to write GTK applications in Python while interacting with native GNOME APIs.
• GTK4: The latest major version of the GTK toolkit provides modern widgets, performance improvements, and better support for animations and modern UI patterns. Using GTK4 helps the application integrate visually and functionally with GNOME desktops.

These technologies also bring trade-offs. Python-based GUI apps rely on system-level libraries for performance-critical tasks and on the underlying toolkit for look and feel. The use of native GNOME stacks supports system accessibility features and theming, which benefits users who depend on assistive technologies.

Data Storage, Privacy and Portability

Open-source desktop apps appeal to users who want control over their data. Workouts stores training records locally on the user’s machine, giving you the ability to back up, export (if supported), or delete your data without relying on a cloud provider.

• Local storage: Sessions and workout history remain on your device unless you choose to sync them manually.
• Export/import: Check the repository for features that enable exporting CSV or JSON. If the app lacks an export feature, local files may still be readable by contributors who can add export tools.
• Privacy: Because there is no default cloud sync, sensitive training data does not leave your machine. This suits users aiming to minimize third-party exposure.

If consistent cross-device syncing is important, look for a project roadmap entry or community-contributed integrations. Some users combine Workouts with cloud file syncing (Nextcloud, Dropbox) by storing the application’s data files in a synced directory, but that depends on the file layout and whether the app tolerates concurrent writes.

Integration with Other Tools and Wearables

Workouts emphasizes desktop planning and logging rather than wearable integration. That said, several practical approaches allow combining Workouts with other tools:

• Manual transfer: Export historical data (if available) and import into spreadsheets or analytics platforms for deeper analysis.
• Complementary apps: Use a wearable or phone-based timer for on-the-fly timing if you prefer not to keep a desktop in arm’s reach. Alternatively, use Workouts’ built-in timers for hold exercises and desktop notifications.
• Community integrations: Open-source projects often attract community scripts or plugins. Check the GitHub issues and pull requests for third-party utilities that bridge Workouts with other services.

Expect limited direct integration with commercial ecosystems unless contributors implement export formats or APIs specifically to support syncing.

Accessibility and GNOME Integration

Using GTK4 and PyGObject gives Workouts access to GNOME’s accessibility stack. That makes it possible to:

• Work with screen readers and keyboard navigation.
• Respect system theming and high-contrast modes.
• Respond to GNOME desktop notifications and audio cues for timers.

Accessibility depends on deliberate design and testing. Open-source applications benefit when contributors and users report issues and supply patches that improve keyboard controls, focus management, and support for assistive technologies.

Contributing and the Development Community

Workouts is published under the GNU General Public License v3.0. The project’s GitHub repository is the primary place to report bugs, request features, and contribute code.

• Report issues: Use GitHub issues to describe bugs or propose feature changes. Provide logs, screenshots, and steps to reproduce where helpful.
• Contribute code: Fork the repository, develop a branch, and submit a pull request. Python and GTK4 knowledge is useful but not required for improving documentation or creating translations.
• Suggest features: Feature requests are best framed with a clear use case. Concrete examples—“add CSV export for training history” or “add an option to set rest alarms with audio notifications”—help maintainers evaluate scope.

Open-source projects thrive when users of varying technical skills contribute: filing detailed bug reports, testing pre-release builds, translating interface strings, and writing documentation.

Scenario: A Real-World Use — Planning a 12-Week Strength Cycle

A practical illustration shows the app’s role in a staged program.

Goal: Increase squat and bench strength over 12 weeks using a linear progression model.

1. Program template: Create three weekly sessions—squat-focused, bench-focused, and accessory/hypertrophy day. Define sets (e.g., squat 5x5, bench 5x5, assistance 3x10).
2. Week-to-week changes: Each successful week, increase weight for the main lifts by 2.5–5 lbs (1–2.5 kg). Log per-set weights and reps.
3. Rest tracking: Record rest durations on heavy days to ensure you allow sufficient recovery for strength sets.
4. Mid-cycle check: At week 6 and week 12, perform a test set for estimated 1RM (or a heavy single) and record the result in a session note.
5. Review: Use the training history to visualize progression—set weights across weeks illustrate steady increases or plateaus.

Workouts provides the framework for consistent record-keeping, enabling the athlete to make objective adjustments based on recorded data.

Best Practices for Logging Accurate Training Data

Accurate logging makes historical records meaningful.

• Record immediate values: Enter weight and reps right after each set to avoid memory errors.
• Note deviations: If you intentionally reduce reps or change tempo, flag the set with a short note if the app supports it.
• Track rest times: Rest durations alter the training effect; logging rest makes sessions consistent and comparable.
• Be honest about AMRAPs and failed sets: Recording a missed target helps spot trends and prevents chasing unsuitable progressions.

Consistent and precise logging elevates raw data into actionable insight over the long term.

Limitations and Where Workouts May Not Fit

No single tool serves every athlete equally. Workouts intentionally targets desktop users and manual logging workflows rather than delivering wearable synchronization or coach-driven programs.

• No guaranteed mobile-first experience: If you train away from a desktop most of the time, a phone-centric app may be more convenient.
• Less automated analytics: Expect manual export to spreadsheets or third-party tools if you want advanced charts or periodization algorithms.
• Syncing depends on community features: Cross-device synchronization may be limited unless contributors add it or you combine the app’s files with a third-party sync service.

These limitations do not undermine the app’s core value: a focused environment for designing workouts and keeping accurate records on a GNOME desktop.

How to Get the Most from Workouts

Maximize the app’s utility with these practical tips.

• Start small: Build a realistic weekly plan and log diligently for the first month. Simple consistency yields better feedback than complex programming applied inconsistently.
• Use the history view weekly: Regular reviews reveal whether weights are trending upward and where to adjust programming.
• Pair with a spreadsheet: Export (if supported) or manually copy key numbers into a spreadsheet for macro-level charts—weight progression over weeks, average reps per exercise, and training frequency.
• Share constructive feedback: Open-source projects evolve through user input. Share feature requests that would make your own workflow smoother.
• Back up data: Regular backups of local data files prevent accidental loss; use your standard backup system or a cloud sync folder if you trust that option.

These practices turn the app into a reliable partner for long-term training.

Comparing Workouts to Alternatives

There are many fitness tracking apps—mobile-first commercial apps, web-based platforms, and other open-source projects. Workouts sets itself apart through:

• Desktop focus: Designed to live in the GNOME ecosystem rather than primarily on mobile.
• Simplicity and transparency: Minimalist feature set, easy to understand.
• Local data ownership: Records stay on your device unless you choose otherwise.
• Open source licensing: Community contributions and auditability under GPLv3.

If you need advanced coaching, cloud-based analytics, or tight integration with wearables, a commercial or phone-first platform may be more suitable. If privacy, desktop use, and simple logging are priorities, Workouts is a strong match.

Practical Walkthrough: Building a Sample Workout in Workouts

A step-by-step walkthrough clarifies the experience.

1. Open Workouts and create a new workout plan. Name it “Lower Strength Week A.”
2. Add exercises:
   • Squat: 5 sets x 5 reps
   • Romanian Deadlift: 3 sets x 6–8 reps
   • Bulgarian Split Squat: 3 sets x 10 reps per leg
   • Plank: 3 timed holds x 60 seconds
3. Create a superset group if you want to pair an accessory exercise (e.g., hamstring curl paired with calf raises).
4. Launch the session from the plan view. The app highlights the first exercise and set.
5. Perform the first set of squats. After completion, enter the weight used and the number of reps. Start the rest timer if desired.
6. Continue through sets, updating values for each. For planks, start the countdown for each hold and let the timer guide you.
7. Finish the session and verify the entries in the training history. Use the recorded values to plan next week’s incremental increases.

This hands-on flow mirrors typical gym behavior while adding structure and permanence to your logs.

Security Considerations

As with any desktop application, the security model depends on how you install and run the software.

• Use trusted sources: Install releases from the official GitHub repository or a reputable distribution channel like Flathub.
• Audit third-party packages: Python apps rely on dependencies; review requirements or consult package maintainers if security is a concern.
• File permissions: Keep data files in your user directory with standard permissions. Avoid running the application with elevated privileges.

Open-source code allows inspection. If you or the community spot security issues, contributors can address them in follow-up commits.

Roadmap Ideas and Potential Improvements

Open-source projects benefit from community-driven roadmaps. Reasonable enhancements for Workouts could include:

• CSV/JSON export for training history to enable analytics in spreadsheets.
• Import templates for common programs (Starting Strength, 5/3/1, PHUL) to help novices get started.
• Sync options (optional) using Nextcloud or other services for multi-device access.
• Customizable timers and audio cues for rest and hold completion.
• RPE, tempo, and program notes fields for richer context.

These items align with user needs commonly expressed in fitness communities. Feature requests framed around concrete use cases are most likely to gain traction with maintainers.

Troubleshooting Checklist

If the app behaves unexpectedly, try these steps.

• Verify dependencies: Ensure system GTK4 and PyGObject libraries are installed and up to date.
• Update the app: Pull the latest changes from the repository or install the latest release.
• Check logs: The app may emit console logs that indicate missing modules or runtime errors.
• Recreate configuration: If data files appear corrupted, moving the configuration to a backup and restarting the app can verify whether the issue is data-related.

When in doubt, file a detailed bug report on GitHub with environment information: OS and version, GTK/runtime versions, and exact steps to reproduce the problem.

Real-World Example: Using Workouts for Coach-Client Sessions

Coaches who prefer desktop tools can use Workouts for client planning and review.

• Build templated plans for clients and export them as files (if the app supports export).
• Have clients run sessions and share their local data files or exported CSVs for review.
• Use the training history to assess adherence, progression, and to adjust upcoming cycles.

This approach requires a bit more manual coordination than a cloud-based coaching platform, but it preserves privacy and reduces dependency on commercial ecosystems.

Community and Next Steps

Workouts is a practical tool with a focused feature set tailored to desktop GNOME users who value local control. The project’s presence on GitHub encourages contributions from developers and feedback from users. If the app matches your workflow, consider:

• Downloading and trying a recent release.
• Reporting issues or feature requests on the GitHub issues page.
• Contributing improvements, documentation, or translations.

Open-source fitness tools can become robust alternatives to proprietary apps when engaged communities drive development.

FAQ

Q: Is Workouts free to use? A: Yes. Workouts is free and open source software released under the GNU General Public License v3.0. The source repository is available on GitHub at github.com/AronCalvert/workouts.

Q: Which platforms does Workouts support? A: Workouts is built with GTK4 and PyGObject and targets GNOME desktop environments on Linux. Confirm platform compatibility and any packaging for other operating systems by checking the project’s GitHub repository and release notes.

Q: How do I install Workouts? A: Look for installation instructions in the project’s GitHub README. The app may be packaged for some Linux distributions or available as a Flatpak on Flathub. If not, cloning the repository and following the documented build or run steps is the typical option. You will need Python 3.x, PyGObject, and GTK4 runtime libraries as prerequisites.

Q: Can I export my workout history? A: The app provides a training history view. For explicit export or import features such as CSV or JSON, check the GitHub repository for existing functionality or open an issue requesting this feature. Community contributions often add export capabilities if they are not already present.

Q: Does Workouts sync with my phone or wearable? A: The core Workouts project focuses on desktop usage and local data storage; direct synchronization with phones or wearables is not a built-in feature unless community-contributed. You can use external syncing methods (file sync tools) or export data to bridge with other services.

Q: Are timed holds and supersets supported? A: Yes. Workouts includes a countdown timer for timed holds and support for grouping exercises into supersets.

Q: Is my data stored locally? A: Yes. Workouts stores training sessions and history on the local device, giving you control over your training data. For cloud sync, use your own sync solution or look for added features in the repository.

Q: How can I contribute? A: Contributions are handled via the project’s GitHub repository. You can contribute by reporting issues, suggesting features, submitting patches or pull requests, translating the interface, or improving documentation.

Q: What are some recommended workflows for using Workouts? A: Create a realistic weekly plan, log each set immediately after completion, track rest times, and review the training history weekly. Pair the app with a simple spreadsheet for macro-level analytics if you want charts or long-term summaries.

Q: Where can I find support or community discussion? A: Open an issue or discussion on the project’s GitHub page. Search for community forums or Linux packaging channels if you need help with installation on specific distributions.

Q: Who maintains Workouts? A: The developer listed in the project is Aron Calvert. For updates, releases, and community work, check the GitHub repository and its contributors.

If you want instructions for a specific distribution, details about packaging format, or a walkthrough tailored to a particular training program, provide your platform and training preferences and precise guidance can be offered.