Cross platform API Client

About

gURL is just another fancy cURL. I am building this because I want to learn Go & desktop app development using Wails, plus it's something that is useful in my day-to-day work.

Declaimer: This is organically grown project. All code you see is handwritten by me. No LLMs were used to generate any code.

Features

It's still in early stage, essential features are implemented.

• Simple UI to configure HTTP Requests
• Workspaces to organize different orgs
• Request history
• Request collections
• Environments
• Mock server
• Request examples
• Response preview for supported media types (Images, Audio, Video, Pdfs etc)
• Import & Export
• Linux & Mac Os supported, Windows support in progress
• Web client is also present, can be self hosted

Screenshots

Web Client

Collections

Environments

Response Previews

Response Example

Mock Server

For every collection a mock server is automatically created. Any saved request examples under the collection can be converted into request mocks. A request mock keeps details about how the incoming request should be handled by mock server.

On request mock you would typically define the path and HTTP method those are required. Optionally you can add Http Headers and Body that server will respond with. Additionally you can also configure status code and delay.

You can toggle mock server on / off from mock servers sidebar. Once the server is up you can click info icon to see the server information

Notice the Authentication Header. It's basic form of protection added for your mock server so if you deploy it to web only you can call the mock server. Without a valid key server will response with 403 response.

If you click three dots on request mock and hit info option you will see details of how you can call the mocked endpoint.

You can utilize environments for interpolating variables within response body and response headers for the mock.

Architecture

This project is designed with a shared core + multiple clients architecture. The goal is to keep all business logic centralized while allowing different frontends (desktop and web) to reuse the same underlying functionality.

Design Principles

• Shared Core: business logic shared avoiding duplication.
• Platform agnostic frontend: dynamically switches implementations based on runtime environment.
• Thin Clients: Client modules act as thin wrappers on top of shared core.
• Separation of Concerns: Clear boundaries between,
  • UI (frontend/)
  • Transport (/desktop, /web)
  • Business Logic (shared/)

Modules

desktop/

• A standalone Go module built using Wails.
• Acts as the desktop client.
• Integrates the Angular frontend via Wails.
• Communicates with the frontend through Wails JS bindings.
• Reuses all core logic from the shared/ module.

web/

• A Go module that uses the standard net/http package.
• Exposes RESTful APIs for backend operations
• Serves the Angular SPA (static files)
• Also depends on the shared/ module for all core functionality.

shared/

• The core module containing all reusable business logic.

• Designed to be platform-agnostic and shared across both desktop and web clients.

• Submodules

  db/

  • Repository layer for interacting with SQLite.
  • Handles persistence and data access.

  assets/

  • embeds static assets in the final binary

  executor/

  • Responsible for executing HTTP requests.
  • Includes logic for request handling, response parsing, and detection.

  import_export

  • Handles import/export functionality.
  • Supports Workspace, collections, requests, environment exports to .json & imports from .json

frontend/

• Angular SPA

• Built with Program to interface architecture:

• Declares abstractions for Storage, Executor, Exporter.

• Provides concrete implementations based on runtime environment

  Environment	Implementation Strategy
  Web	Calls backend via REST APIs
  Desktop	Uses Wails JS bindings

• allows the same frontend codebase to work in both desktop & client mode and can be extended further.

Request Flow

Roadmap

• Workspace Operations - import/export, delete, rename etc.
• Importing Open API 2.0, 3.0 and 3.1 specs as usable collections
• Oauth 1.0 & 2.0 authorization support.
• WSS, GRPC, SOAP support.
• pre & post scripts.
• Git integration
• Web Hooks testing & replayability
• Ability to execute collections and add tests
• OAS generation

Acknowledgments

• Wails Project
• Angular V21
• Daisy UI
• Lucide Icons
• Sqlite
• GORM
• mime-db
• nanoid
• go-nanoid
• Biome

License

MIT