Ecode

<h1 align="center"> <img align="center" src="https://raw.githubusercontent.com/SpartanJ/eepp/develop/bin/assets/icon/ecode-icon-web.svg" width="128" height="128" /><br/> ecode </h1>

ecode is a lightweight multi-platform code editor designed for modern hardware with a focus on responsiveness and performance. It has been developed with the hardware-accelerated eepp GUI, which provides the core technology for the editor. The project comes as the first serious project using the eepp GUI, and it's currently being developed to improve the eepp GUI library as part of one of its main objectives.

Screenshots

For more screenshots checkout running on macOS, running on Windows, running on Haiku, low dpi, code completion, terminal, file locator, file formats, global find, global replace, linter.

Notable Features

• Lightweight
• Portable
• Uncluttered GUI
• Syntax Highlighting (including nested syntax highlighting, supporting over 100 languages and LSP semantic highlighting)
• Multi-cursor support
• LSP support
• Debugger support via Debug Adapter Protocol
• Git integration
• Terminal support
• Command Palette
• Auto-Completion
• Customizable Linter support
• Customizable Formatter support
• Customizable Color-Schemes
• Customizable keyboard bindings
• Configurable build pipelines
• Fast global search (and replace)
• AI Assistant plugin
• Minimap
• Unlimited editor splitting
• Easily extendable language support
• Customizable and scalable (non-integer) GUI (thanks to eepp GUI)
• Dark & Light Mode
• File system Tree View (with real-time file system changes)
• Smart hot-reload of files
• Folders as Projects with .gitignore support *
• Per Project Settings
• Smart and fast project file locator
• Multiline search and replace
• Project/Folder state persist between sessions
• Soft-wrap
• Code-folding
• Session Snapshot & Periodic Backup
• Perl Regular Expressions and Lua pattern searches support
• Plugins support (linter, spell checker, LSP, DAP, Git, and more).

Folder / Project Settings (*)

In ecode, folders are treated as projects, similar to other code editors. However, ecode distinguishes itself by using the repository's .gitignore file as a project configuration to streamline file management.

Automatic File Filtering

ecode automatically excludes files listed in the .gitignore file when indexing project files. This ensures that only relevant files are considered for project-wide searches and navigation, resulting in faster and more accurate search outcomes.

Customizing File Inclusion

To override .gitignore filtering, ecode supports two configuration files in the .ecode/ subfolder:

• .prjallowed: Add glob patterns to include files ignored by .gitignore, making them available for indexing and searching.
• .prjdisallowed: Add glob patterns to exclude files that are not ignored by .gitignore, providing precise control over file visibility.

Supported File Types

By default, ecode indexes only file types it officially supports. Unsupported files are excluded unless their patterns are explicitly added to the .ecode/.prjallowed file.

This approach ensures an efficient and tailored project management experience with flexible customization options.

Philosophy

Some points to illustrate the project philosophy:

• Extendable functionality but in a controlled environment. New features and new plugins are accepted, but the author will supervise any new content that might affect the application quality and performance.
• Load as few files and resources as possible and load asynchronously as many resources as possible. Startup time of the application is considered critical.
• Use the machine resources but not abuse them.
• The editor implementation will try to prioritize performance and memory usage over simplicity.
• Developed with modern hardware in mind: expected hardware should have low file system latency (SSD), high cores count and decent GPU acceleration.
• Plugins and non-main functionality should never lock the main thread (GUI thread) or at least should block it as little as possible.
• Terminals are part of the developer workflow.

Live Demo

ecode can be compiled to WASM and run in any modern browser. There are no plans to focus the development on the web version (at least for the moment) since there are plenty of good solutions out there. But you can give it a try:

Demo here

Demo Clarifications

• You'll need a modern browser with SharedArrayBuffer support
• Linter, Formatter, LSP Client and Debugger plugins won't work since they work by running other processes (except for the native formatters that are available)
• WebGL renderer isn't optimized, so it's not as fast as it could/should be (still, performance is good in chromium based browsers)
• Demo is designed for desktop resolutions (mobile is unusable, IME keyboard won't show up due to an emscripten limitation)

Source Code

Currently, the source code is located at the eepp project repository. ecode editor source is located at src/tools/ecode. ecode is being used to actively improve and iterate the eepp GUI library. At some point, it will be migrated to this repository. The ecode repository should be used for issues and documentation. PRs for ecode will be accepted at the eepp repository.

Build from Source

There are scripts for each supported platform ready to build the application. For Linux and macOS it is trivial to build the project, you'll just need to have GCC/Clang installed and also the development library from libSDL2. Windows build script is currently a cross-compiling script and it uses mingw64. But it also can be easily built with Visual Studio and libSDL2 development libraries installed. For more information on how to build manually a project please follow the eepp build instructions. The project name is always ecode (so if you are building with make, you'll need to run make ecode).

• Linux build script can be found here. Running build.app.sh will try to build the AppImage package and tar.gz with the compressed application. ecode folder will contain the uncompressed application.
• macOS build script can be found here. Running build.app.sh will create ecode.app. Run create.dmg.sh to create the dmg file. ecode.app folder will contain the uncompressed application.
• Windows cross-compiling build script can be found here. Running build.app.sh will create a zip file with the zipped application package. ecode folder will contain the uncompressed application. To build from Windows follow the instructions here.
• FreeBSD build script can be found here. Running build.app.sh will try to build a tar.gz with the compressed application. ecode.app folder will contain the uncompressed application.
• Haiku build script can be found here. Running build.app.sh will try to build a tar.gz with the compressed application. ecode.app folder will contain the uncompressed application.

Nightly Builds

Nightly builds are being distributed here for the more impatient users. ecode is being developed actively, nightly builds may not be stable for daily usage unless there's a pending unreleased fix required for the user.

Plugins

Plugins extend the base code editor functionality. Currently all plugins are enabled by default, but they are optional and they can be disabled at any time. ecode implements an internal protocol that allow plugins to communicate with each other. The LSP protocol is going to be used as a base to implement the plugin communication. And, for example