/pycode

A Lightweight and Modular TUI IDE written in Python.

Primary LanguagePython

Pycode: A Lightweight and Modular TUI IDE

Background

In a landscape dominated by feature-rich but often resource-intensive IDEs, this project was born from a need for a development environment that is lightweight, fast, and fully terminal-based. This IDE is not just a tool; it's a testament to the principle of efficiency without compromise. It's designed to run seamlessly in minimalist environments like a VPS or low-resource machines, without sacrificing essential functionality.

Vision

The core vision of this project is to deliver a highly modular IDE. Each component is purpose-built to focus on a single task and work together in harmony. The IDE aims to provide an intuitive and rapid coding experience by separating the logic for the user interface, the text editor, and supporting functionalities like Git, manageable modules. With this approach, we aim to prove that high performance and modern features can coexist within the terminal environment.

Technology Stack

This project is built on a foundation of proven and efficient technologies. Each choice was made with performance and ease of development in mind.

  • Textual: Serves as the primary framework for building the Terminal User Interface (TUI). Textual was chosen for its modern approach to managing complex layouts and widgets.
  • prompt-toolkit: The engine for the text editor. This is a crucial choice to ensure the editor can handle large files efficiently by only rendering the visible parts.
  • GitPython: This library acts as the bridge for seamless Git integration, enabling features like file status detection and line-by-line code changes.

Code Partner

This project is the result of a unique collaboration between a visionary developer and an AI assistant.

  • gtkrshnaaa: The primary developer and architect who conceived the project's core concepts and vision.
  • Caecillia (@gtkrshnaaa AI Assistant): An AI collaborator who assists in brainstorming ideas, mapping the architecture, and providing technical solutions throughout the development process.

Conceptual Map: TUI IDE Architecture

1. Core Foundation

  • Main Application: Textual
    • Acts as the primary framework.
    • Manages the layout with a panel and widget system.
    • Responsible for rendering the overall interface.
  • Core Component: prompt-toolkit
    • Functions as the efficient text editor engine.
    • Embedded within the main Textual panel.
    • Manages all typing, cursor navigation, text buffer, and syntax highlighting logic.

2. User Interface Components

  • Left Sidebar: Directory Tree Widget
    • Purpose: Displays the hierarchical directory and file structure.
    • Interaction: Sends a signal to the editor panel when a user selects a file.
    • Git Integration: Displays the Git status of each file/directory (e.g., M for modified, U for untracked).
  • Center Panel: Text Editor Widget (from prompt-toolkit)
    • Purpose: Displays and allows editing of the selected file's content.
    • Features:
      • Standard key bindings (Ctrl-S, Ctrl-C, Ctrl-V).
      • Syntax highlighting (requires additional logic).
      • Cursor navigation and scrolling.
      • Undo/Redo functionality.
      • Git diff visualization on a per-line basis.
  • Bottom Panel: Interactive Command/Search Panel
    • Purpose: A constantly visible, multi-functional panel that serves as an area for quick searches, command execution, and status display.
    • Features:
      • Prompt Input: A dynamic input field. When no command is active, it can display a placeholder text like "Type to search..." or "Press Ctrl-P for commands...".
      • Dynamic Content: The main area of this panel changes its content depending on the active mode.
      • Result List: When search mode is active, this area displays a list of matching files in real-time. Each item in the list shows the relative file path and its Git status.
      • Status Bar: When no command or search is active, this panel can display important status information, such as the current Git branch or brief messages.

3. Smart Features & Integrations

  • Quick File Search
    • Concept: Utilizing the always-present bottom panel as the primary interface for file search.
    • Process:
      1. The user presses a shortcut (Ctrl-P) to activate the search mode.
      2. The input field in the bottom panel changes, perhaps showing an icon or label indicating that search mode is active.
      3. As the user types, the Result List immediately appears below the input field, showing real-time fuzzy search results.
      4. The user can navigate the results with the up/down arrow keys.
      5. When the user presses Enter, the selected file is opened in the editor and the bottom panel returns to its default mode (e.g., displaying the status bar or an empty prompt).
  • Git Integration
    • Library: GitPython
    • Workflow:
      1. The IDE detects changes in the Git repository.
      2. Uses GitPython to get the status and diff.
      3. Displays a status indicator on the Directory Tree (e.g., an M icon).
      4. Sends the diff data to prompt-toolkit to visualize line changes in the editor.

Conclusion: Pycode - A New Paradigm for TUI IDEs

The Pycode project represents a significant step forward in the world of terminal-based development. While many IDEs prioritize a wide array of features, often at the cost of performance and resource efficiency, Pycode was conceived with a different philosophy: to create a development environment that is lightweight, fast, and highly modular.

By leveraging a carefully selected technology stack—including Textual for the UI, prompt-toolkit for the core editor, and GitPython for seamless Git integration—Pycode proves that a terminal-based IDE can deliver a powerful and intuitive coding experience. This project isn't just a tool; it's a demonstration that high performance and modern features can coexist harmoniously within a minimalist, resource-friendly environment.

In essence, Pycode challenges the conventional idea of what an IDE should be. It’s a testament to the principle that with a clear vision and a smart, modular design, you can build something truly powerful that is also efficient and elegant.