EasyAlias

EasyAlias is a small desktop app project for creating, viewing, and managing local terminal shortcuts through a UI.

The idea: instead of manually editing shell files or hand-maintaining command scripts, EasyAlias gives you a simple interface. You enter a command name, choose a file or folder, select what should happen from a dropdown, and the app generates the matching platform-specific command.

Website | Mac App Store | GitHub | Reddit

❤️ Support EasyAlias

Hi, I'm Hannes, the creator of EasyAlias and a Software Engineering student.

If EasyAlias saves you time, consider supporting its development.

Your sponsorship helps me fix bugs, develop new features, and keep EasyAlias free and open source.

Become a GitHub Sponsor

Install on macOS

Install the sandboxed edition from the Mac App Store, or install the direct desktop edition as a Homebrew cask:

brew tap hannesgnann-hub/tap
brew trust hannesgnann-hub/tap
brew install --cask easyalias

Install on Linux

The current Homebrew formula supports ARM64 Linux systems:

brew tap hannesgnann-hub/tap
brew trust hannesgnann-hub/tap
brew install easyalias

What EasyAlias Solves

Small terminal shortcuts tend to pile up over time:

• quickly jumping into project folders
• opening files or spreadsheets
• remembering build commands
• shortening SSH connections
• saving recurring shell commands under short names

Normally, these shortcuts end up scattered across shell config files, random .cmd folders, notes, and terminal history. EasyAlias keeps this cleaner:

• Shell config and PATH setup stay small.
• Shortcut data is stored in a structured file.
• Generated command files are owned by the app.
• Editing happens through a UI.

flowchart LR
  A["Manual shortcuts in shell files or .cmd folders"] --> B["Hard to scan and easy to break"]
  B --> C["EasyAlias UI"]
  C --> D["Structured shortcut data"]
  D --> E["Generated platform files"]
  E --> F["Terminal uses short commands"]

Current Status

EasyAlias has separate Tauri source projects for direct macOS distribution, the sandboxed Mac App Store edition, Windows, and Linux. They share the same product direction while using the native terminal integration and security model for each platform.

The direct macOS, direct Windows, Linux, and Mac App Store source trees share the current day-to-day management tools:

• pin favorites above the regular alias list
• search and filter aliases by name, command, favorites, and categories such as Git, Docker, Navigation, and Build
• browse 36 suggestions across paginated views and add one with a single click
• export all or selected aliases to a portable, versioned JSON backup
• validate and review all or selected entries before importing a backup
• restore deleted aliases from Trash for 30 days, or remove them permanently
• dismiss status messages manually or let them disappear after three seconds

The direct macOS, direct Windows, and Linux editions also share the automation and app-shell tools (the sandboxed Mac App Store edition intentionally omits these):

• build and run multi-step Automations (shell commands and timed waits) with favorites, groups, a 30-day Trash, and portable JSON backup
• schedule an automation as a Timed Automation: a fixed clock time, or that day's real sunrise/sunset for a chosen region, optionally on specific weekdays — it fires through the operating system's own scheduler, so it runs even while EasyAlias is closed
• assign a global keyboard shortcut to any automation and trigger it from anywhere while EasyAlias is running, either surfacing the run window or running it silently in the background
• a Settings view for appearance (Light / Dark / System), shortcut behavior, the alias-suggestions toggle, and start-at-login
• closing the window keeps EasyAlias running in the menu bar / system tray so shortcuts stay active; the tray menu shows the window again or quits

The macOS version can:

• create aliases
• edit existing aliases
• move aliases to the 30-day Trash, then restore or permanently remove them
• choose files and folders through the native macOS picker
• show a preview of the generated command
• detect and safely import selected existing aliases from .zshrc, .bash_profile, and .bashrc on first start or from the header import button
• add useful suggested macOS aliases with one click
• store createdAt and updatedAt
• automatically connect ~/.easyalias/aliases.zsh to .zshrc, .bash_profile, and .bashrc
• start from the terminal through easya if the app is installed at /Applications/EasyAlias.app
• search and filter the alias list by name, command, or category (Favorites, Git, Docker, Navigation, Build)
• build and run multi-step Automations (shell commands and timed waits) in a chosen working directory
• schedule automations by clock time or local sunrise/sunset through launchd, and trigger them with a global keyboard shortcut
• keep running in the macOS menu bar after the window is closed, and optionally start hidden at login

The Mac App Store version can:

• run inside Apple's App Sandbox
• store structured data and backups in its app container
• connect only to a Home folder explicitly selected through the native file picker
• persist that permission with a security-scoped bookmark
• manage clearly marked alias blocks in .zshrc, .bash_profile, and .bashrc
• import existing aliases only after the Home folder has been connected
• build a universal signed .app and installer-signed .pkg for App Store Connect

The Windows version can:

• create, edit, and delete Windows command shortcuts
• detect and safely import selected simple .cmd/.bat aliases from user-owned PATH folders on first start or on demand
• add useful suggested Windows commands with one click
• choose files and folders through the native Windows picker
• generate .cmd files under ~/.easyalias/bin
• connect the command folder to the user PATH, so aliases work in cmd.exe
• build and run multi-step Automations (cmd.exe commands and timed waits) in a chosen working directory
• schedule automations by clock time or local sunrise/sunset through Task Scheduler, and trigger them with a global keyboard shortcut
• keep running in the Windows system tray after the window is closed, and optionally start hidden at login
• build as a Windows installer target through Tauri/NSIS; the same installer can be hosted for the Microsoft Store EXE/MSI workflow

The Linux version can:

• create, edit, and delete bash/zsh aliases
• detect and safely import selected existing aliases from .bashrc or .zshrc on first start or on demand
• add useful suggested Linux aliases with one click
• choose files and folders through the native Linux picker
• detect bash or zsh from $SHELL
• generate ~/.easyalias/aliases.sh
• connect the generated file to ~/.bashrc or ~/.zshrc
• build and run multi-step Automations (bash/zsh commands and timed waits) in a chosen working directory
• schedule automations by clock time or local sunrise/sunset through systemd user timers, and trigger them with a global keyboard shortcut
• keep running in the system tray after the window is closed, and optionally start hidden at login
• build .deb, .rpm, and .AppImage packages

Feature Tour

The screenshots show the current direct macOS edition. Windows and Linux share these workflows with platform-specific commands and storage locations. The sandboxed Mac App Store edition shares the alias-management screens but intentionally omits automations, schedules, global shortcuts, menu-bar controls, and start-at-login.

Favorites and Daily Management

Click the star beside an alias to pin it above regular entries. Favorites and non-favorites are each sorted alphabetically.

The alias list is paginated so large collections stay compact. Search matches both alias names and command contents; the filter menu narrows the list by category.

Paged Suggestions

Suggestions start collapsed. Open the section to browse Git, Docker, build-tool, networking, and filesystem shortcuts. Nine suggestions are shown per page; Use saves one immediately.

Selective Backup and Restore

The export dialog writes only the selected aliases to a portable .json file. The import dialog accepts that file through the picker or drag and drop, validates it before showing its contents, and lets you choose exactly what to restore.

Recoverable Deletion

Deleting an alias moves it to Trash instead of removing it immediately. Deleted aliases remain recoverable for 30 days and can be restored, permanently deleted, or cleared together.

Automations

The automations view (top-right play icon) is a separate workspace for repeatable, multi-step workflows. An automation has a name, a working directory, and an ordered list of Command and Wait steps that all share one shell session, so a cd or exported variable carries across steps. Automations have their own favorites, free-text group labels, search/filter, a 30-day Trash, and portable JSON backup. If the working directory field points at a file, the run uses the folder that contains it.

Timed Automations

The clock icon on an automation card opens its schedule. Pick a trigger:

• Time — a fixed HH:MM.
• Sunrise / Sunset — that day's real event, recomputed daily, for an approximate region chosen from a dropdown (e.g. "EU Central (Berlin)").

Optionally restrict it to specific weekdays. EasyAlias registers the schedule with the operating system's own scheduler (launchd on macOS, systemd --user timers on Linux, Task Scheduler on Windows), so a timed automation still fires when EasyAlias itself is not running. Clock-time entries get an exact-fire job each; sunrise/sunset entries ride a shared periodic checker. The card and modal show the outcome of the most recent run.

flowchart LR
  Card["Automation card"] --> Schedule["Schedule modal"]
  Schedule --> Kind{"Trigger"}
  Kind -- "Time HH:MM" --> ClockJob["Exact-fire OS job"]
  Kind -- "Sunrise / Sunset" --> SunCheck["Shared periodic checker + region"]
  ClockJob --> Runs["Automation runs (app open or closed)"]
  SunCheck --> Runs

Keyboard Shortcuts

The keyboard icon on an automation card records a global shortcut (for example Cmd+Shift+L). While EasyAlias is running it fires that automation from anywhere. The Settings view chooses what a press does: bring the run window forward with live output, or run it silently in the background. A shortcut already claimed by the system or another app is rejected without being saved. Global shortcuts need a running process — see Menu Bar & Startup below.

Settings

The gear icon (far right of the header) opens Settings:

Preferences are stored in ~/.easyalias/settings.json.

Menu Bar & Startup

Closing the window no longer quits EasyAlias — it hides the window and the app keeps running in the menu bar (macOS) or system tray (Windows/Linux), so scheduled and shortcut triggers stay available. The tray menu has Show EasyAlias and Quit EasyAlias; a left click also reveals the window. Turning on Start at login launches EasyAlias hidden in the tray when you sign in.

Tutorial

The graduation-cap button at the far right of the header opens a built-in tutorial: pick the alias area, the automations area, or how to support me, then step through an illustrated walkthrough.

Folder Structure

easyalias/
  mac_src/          macOS source code for the Tauri app
  mac_export/       built macOS export, e.g. EasyAlias.zip
  mac_src_app_store/ sandboxed macOS source for Mac App Store distribution

  windows_src/      Windows source code for the Tauri app
  windows_export/   built Windows installer exports

  linux_src/        Linux source code for the Tauri app
  linux_export/     built Linux packages

  README.md         this project overview

Documentation is split by scope:

flowchart TD
  Root["easyalias/"]
  Root --> MacSrc["mac_src/ macOS source"]
  Root --> MacExport["mac_export/ macOS export"]
  Root --> MacStore["mac_src_app_store/ sandboxed macOS source"]
  Root --> WinSrc["windows_src/ Windows source"]
  Root --> WinExport["windows_export/ Windows exports"]
  Root --> LinuxSrc["linux_src/ Linux source"]
  Root --> LinuxExport["linux_export/ Linux exports"]
  Root --> RootReadme["README.md project overview"]

  MacSrc --> MacFrontend["src/ macOS UI"]
  MacSrc --> MacBackend["src-tauri/ macOS backend"]
  MacSrc --> MacDocs["docs/ macOS architecture"]
  MacStore --> StoreFrontend["src/ Store UI"]
  MacStore --> StoreBackend["src-tauri/ sandbox backend"]
  MacStore --> StoreDocs["docs/ Store architecture"]
  WinSrc --> WinFrontend["src/ Windows UI"]
  WinSrc --> WinBackend["src-tauri/ Windows backend"]
  WinSrc --> WinDocs["docs/ Windows architecture"]
  LinuxSrc --> LinuxFrontend["src/ Linux UI"]
  LinuxSrc --> LinuxBackend["src-tauri/ Linux backend"]
  LinuxSrc --> LinuxDocs["docs/ Linux architecture"]

macOS

The macOS source lives in:

mac_src/

Install the released app with Homebrew:

brew tap hannesgnann-hub/tap
brew trust hannesgnann-hub/tap
brew install --cask easyalias

Typical workflow:

cd mac_src
npm install
npm run tauri dev

Build:

npm run tauri build

Export:

cp -R src-tauri/target/release/bundle/macos/EasyAlias.app /Applications/
ditto -c -k --keepParent src-tauri/target/release/bundle/macos/EasyAlias.app ../mac_export/EasyAlias.zip

Mac App Store

The sandboxed edition is available on the Mac App Store.

The sandboxed Store source lives in:

mac_src_app_store/

It is intentionally separate from mac_src/. Before it can manage aliases, the user selects the Home folder once and macOS grants persistent access through a security-scoped bookmark. EasyAlias then works only with .zshrc, .bash_profile, and .bashrc inside that selected folder.

Run the source checks:

cd mac_src_app_store
npm install
npm run build
cargo test --manifest-path src-tauri/Cargo.toml

The final App Store build additionally requires Apple Distribution and Mac Installer Distribution certificates plus a Mac App Store Connect provisioning profile. See mac_src_app_store/README.md for the exact registration, signing, .pkg, and upload steps.

Windows

The Windows source lives in:

windows_src/

Typical workflow on Windows:

cd windows_src
npm install
npm run tauri dev

Build:

npm run tauri build

The Windows version uses the same UI and product idea, but integrates with cmd.exe instead of zsh.

The generated NSIS installer can also be hosted and submitted through the Microsoft Partner Center EXE or MSI app workflow. Use /S for unattended NSIS installation when the Store submission asks for a silent-install parameter.

Linux

The Linux source lives in:

linux_src/

Typical workflow on Linux:

cd linux_src
npm install
npm run tauri dev

Build .deb, .rpm, and .AppImage packages:

npm run tauri build

The Linux version detects bash or zsh, creates ~/.easyalias/aliases.sh, and connects it to the matching shell startup file. Full prerequisites and export commands are documented in linux_src/README.md.

Cross-Platform Builds

Development can be coordinated from a Mac, but release packages should be produced on the operating system they target:

A Windows or Linux VM works for occasional builds. For repeatable releases, use separate macOS, Windows, and Linux jobs in a CI matrix and upload their artifacts to one release. Tauri documents this pattern in its GitHub Actions guide. Windows MSI output requires Windows, while the configured NSIS target can also be cross-compiled with additional tooling; see the Windows installer guide. Linux packages should be built on Linux because their native libraries and compatibility baseline matter.

flowchart LR
  Shared["Shared idea and UI"]
  Shared --> Mac["macOS"]
  Shared --> MacStore["Mac App Store"]
  Shared --> Win["Windows"]
  Shared --> Linux["Linux"]

  Mac --> MacShell["zsh and Bash startup files"]
  MacShell --> ZshFile["~/.easyalias/aliases.zsh"]
  ZshFile --> MacStartup["source in .zshrc, .bash_profile, and .bashrc"]

  MacStore --> Bookmark["User-selected Home-folder bookmark"]
  Bookmark --> ManagedBlock["Managed blocks in three startup files"]

  Win --> Cmd["cmd.exe"]
  Cmd --> Bin["$HOME/.easyalias/bin/*.cmd"]
  Bin --> Path["folder in User PATH"]

  Linux --> Shell["bash or zsh"]
  Shell --> ShellFile["~/.easyalias/aliases.sh"]
  ShellFile --> ShellRc["source in ~/.bashrc or ~/.zshrc"]

macOS uses:

~/.easyalias/aliases.zsh
source ~/.easyalias/aliases.zsh

Windows uses:

%USERPROFILE%\.easyalias\bin
%USERPROFILE%\.easyalias\bin\beerv2.cmd

Instead of zsh alias lines, Windows generates .cmd files, for example:

@echo off
cd /d "%USERPROFILE%\Desktop\projects\beerv2_app"

After the first Windows app start, open a new cmd.exe window so the updated user PATH is visible. You can verify command resolution with:

where beerv2

Linux uses:

~/.easyalias/aliases.sh
source ~/.easyalias/aliases.sh

After the first Linux app start, open a new terminal or reload the detected shell startup file with source ~/.bashrc or source ~/.zshrc.

Import Existing Aliases

Fresh direct-install editions automatically detect existing aliases and offer a one-time selection dialog. The Mac App Store edition performs that scan only after the user explicitly connects the Home folder. After the prompt has been handled, the import icon in the top-right corner can rescan the same platform-specific source at any time. EasyAlias never imports silently and creates a backup before confirmed source data is changed.

Complex, nested, repeated, multiline, malformed, or location-dependent definitions are skipped rather than guessed. Aliases already managed by EasyAlias are excluded from later rescans. Selecting Skip Import leaves existing aliases unchanged and closes only the automatic first-start prompt; the import icon remains available.

flowchart TD
  Start["Open EasyAlias"] --> Trigger{"First start with candidates?"}
  Trigger -- "yes" --> Review["Review detected aliases"]
  Trigger -- "no" --> Main["Alias manager"]
  Main -->|"click import icon"| Rescan["Rescan platform source"]
  Rescan --> Found{"New safe aliases found?"}
  Found -- "no" --> Message["Show no-new-aliases message"]
  Found -- "yes" --> Review
  Review --> Select["Select entries"]
  Select --> Backup["Create backup"]
  Backup --> Import["Store managed aliases"]

This legacy-import flow is separate from portable backup import. The legacy scanner migrates aliases already present in platform configuration files; the backup dialog restores EasyAlias JSON files created with the export button.

Portable Backups

Portable backups use the same versioned JSON envelope in the direct macOS, Windows, Linux, and Mac App Store editions. This makes it possible to move selected aliases between those EasyAlias installations while reviewing every entry before it changes the destination configuration.

flowchart LR
  Managed["Managed EasyAlias aliases"] --> SelectExport["Select aliases to export"]
  SelectExport --> Json["Versioned EasyAlias JSON backup"]
  Json --> Validate["Validate and inspect backup"]
  Validate --> SelectImport["Select aliases to import"]
  SelectImport --> Merge["Replace matching names and add new aliases"]

The importer rejects unsupported formats, malformed entries, duplicate ids or names, and files larger than 5 MB. Unselected aliases remain unchanged.

Alias Actions

Target Vision

EasyAlias should become a small, practical tool for recurring local developer commands:

• simple enough for quick alias maintenance
• robust enough to avoid breaking shell files
• platform-aware for macOS, Windows, and Linux
• exportable as a regular desktop app

The focus is not a cloud service or account system, but a local, fast helper for your own machine.

mindmap
  root((EasyAlias))
    Local
      No cloud
      Own files
      Fast access
    UI
      Create
      Edit
      Favorite
      Recover deleted aliases
      File picker
      Paged suggestions
      Settings and themes
    Shell
      zsh on macOS
      cmd on Windows
      bash or zsh on Linux
      Generated files
    Automations
      Multi-step workflows
      Timed by clock or sunrise/sunset
      OS scheduler runs them when closed
      Global keyboard shortcuts
      Menu bar / system tray
    Export
      Portable JSON backup
      macOS app
      Windows installer
      Linux packages

License

EasyAlias is available under the MIT License.