Zep - An embeddable editor, with optional support for using vim keystrokes.

Zep - A Mini Editor

Builds GitHub license Codacy Badge Codacy Badge codecov Gitter

Zep is a simple embeddable editor, with a rendering agnostic design and optional Vim mode. It is built as a shared modern-cmake library. The core library is dependency-free (the demo application requires an installed package), and it is possible just to copy the files into your project and build it. Out of the box Zep can draw to a Qt Widget or an an ImGui window - useful for embedding in a game engine. A simple syntax highlighting engine is provided, and can easily be extended. Basic theming support is included, and window tabs and vertical/horizontal splits are also available. Zep is 'opinionated' in how it does things, but is easy to modify and supports many common features. It is heavliy influenced by Vim, but has a good notepad-style editing mode too. A simple search feature (Ctrl+P) is a powerful way to find things, and a Repl mode is useful for implementing a console for game scripting. Intended to eventually sit inside a live-coding environment, Zep also has a minimal mode and several configuration options which can be set in a simple toml-format file.

Video Overview

Zep Overview



Zep supports the standard editing keystrokes you'll find in most editors, along with a reasonable subset of modal Vim editing as an option. The demo project lets you switch between the editing modes on the fly. Zep is not meant to replace Vim. I don't have a lifetime spare to write that, but it has most of the functionality I use day to day, and anything missing gets added over time. A keymapper enables configuration of Zep outside the standard modes offered.

Zep is ideally suited to embedding in a game engine, as an in-game editor, or anywhere you need a simple editor without a massive dependency on something more substantial like NeoVim. The core library is dependency free, small, and requires only a modern C++ compiler. Zep can be included in your project building a dependency-free modern cmake library, and setting Zep::Zep in target_link_libraries. A header-only implementation of the ImGui and Qt backends is provided as an addendum to the core library; this enables Zep to render in an ImGui or Qt environment. After building and installing Zep on your system, only 2 lines are required in your CMakeLists to use it. An alternative would be to just copy and build the source files for the core library into your project.

The demos for Qt and ImGui require dditional packages, but these aren't required to embed Zep in your application. The ImGui demo builds and runs on Windows, Linux and Mac OS. If you're a Vim user, you might often suffer the frustration of not being able to use Vim keystrokes in your tools. Zep solves that.

Key Features:

  • Modal 'vim' or modeless 'standard' editing styles; built around a common core of functionality.
  • Keymapper for extending existing modes or adding new commands
  • Qt or ImGui rendering (and extensible)
  • Terminal-style text wrapping and work in progress non-wrapped mode
  • Splits and tabs
  • A simple syntax highlighting engine, with pluggable secondary highlighters
  • Theme support
  • A Repl for integrating a command/scripting language (the demo project integrates a Scheme interpreter)
  • CTRL+P search for quick searching files with fuzzy matching
  • Text Markers for highlighing errors, etc.
  • No dependencies, cross platform, small library
  • Builds on VC 2017, GCC 6, Clang. C++14 is the basic requirement
  • A work in progress extension mode to support an Orca-like environment
  • A work in progress tree control for file navigation

New Features, recently added:

  • Support for tabs instead of spaces; display of tabs as whitespace arrows.
  • UTF8 (Work in progress - not completely done yet).
  • More generic keymapping for extensible modes
  • /search support

Current Limitations:

  • Vim mode is limited to common operations, not the extensive set of commmands typical in Neovim/Vim. There are now a considerable number of commands, but notably ex commands are missing, such as %s///g for find/replace.

Though I have limited time to work on Zep, I do try to move it forward at York Developer's regular Code and Coffee sessions. Zep was my 2018 project but has already proved quite popular, and I try to throw more features in when I can. There are over 200 unit tests for the editing modes. This project started mainly as an experiment and a learning exercise. I like the idea of a programmer building programmer tools for their own use, just as carpenters used to build their toolbox.

One of my targets for Zep is to get it to the point where I can use it as a standalone editor for common tasks. It is almost equivalent to how I'd use NeoVim day-to-day. The other target is to use Zep in a live coding environment.

Pull requests are appreciated and encouraged ;)


Live Coding in 'Minimal' Mode: LiveCoding

Using the ImGui Renderer: ImGui

Using the Qt Renderer: Qt

A light theme: Qt

Embedded in a Live Coding tool: Embedded

Embedded in a Game Engine: Embedded



Zep is built from simple interacting layers for simplicity.


The text layer manages manipulation of text in a single buffer. At the bottom level, a gap buffer struture maintains the text information. The buffer layer is responsible for saving and loading text, and supporting simple search and navigation within the text. Much of the higher level mode code uses the buffer commands to move around inside the text. A GlyphIterator is used within the buffer in order to walk along it in UTF8 code-points.

A command layer supplies functions to add and remove text, and supports undo; all buffer modifications are done with these simple commands.

The Mode layer supports editing text using Vim commands, or using standard notepad-like commands.

A Syntax layer monitors the buffer and provides file-specific syntax coloring. Syntax highlighting can be easily extended


Tab windows are like workspaces, each containing a set of windows arranged in splits. The window lass arranges the rendering and calls a thin display layer to draw the text. This makes it simple to draw the editor using different rendering code. Adding Qt took just an hour to do.

Vim & Standard Modes

Mode plugins provide the editing facility - currently that is Vim & Standard and extension modes for the Repl and the Search panels. The Vim mode has most of the usual word motions, visual mode, etc. The standard mode has the usual shift, select, cut/copy/paste, etc. See Vim Mode, or the top of the mode_vim.cpp file for a list of supported operations in Vim


You can follow the build buttons above to see the build process or look in the travis or appveyor scripts.

1. Get the Source

git clone https://github.com/Rezonality/zep zep
cd zep

2. Add extra packages

If you don't have them already, the following packages are required, depending on your system. Note, that SDL is part of the build, and not installed seperately. It is only used for the demo, not the core editor library or unit tests. Qt is required to build the Qt demo on linux. If you have compilation problems, you might need to investigate the compiler you are using. Ubuntu 16 & 17 both have a recent enough version for it to work. On Ubuntu 14 I tend to upgrade to g++6 The Qt app builds on linux, but is not part of the travis setup yet.


sudo apt install cmake  
sudo apt install git  


brew install cmake
brew install git

3 Install the Zep library as a package

Here is a typical build instruction for windows, assuming you have just synced this repo:

mkdir build
cd build
cmake -G "Visual Studio 16 2019" -A x64 -DZEP_FEATURE_CPP_FILE_SYSTEM=1 -DBUILD_IMGUI=0 -DBUILD_TESTS=0 -DBUILD_DEMOS=0 ..
cmake --build . --target install

At this point your system will have installed the zep library. You can add its paths and library to your project like this:

find_package(Zep REQUIRED)
target_link_libraries(MYPROJECT PRIVATE Zep::Zep)

4. Building the Demo

The Zep demo now requires my external MUtils library in order to run. To make the demo, hop over to https://github.com/Rezonality/mutils and build/install it. Here's an example script for the complete process to build the support library and all of the zep demos.


# MUtils
git clone https://github.com/Rezonality/mutils
cd mutils

# Zep
git clone https://github.com/Rezonality/zep
cd zep
set QT_INSTALL_LOCATION=C:\Qt\5.10.0\msvc2017_64 (for example - required for building QT)
config.bat OR config_qt.bat or config_imgui.bat (for qt and imgui respectively)


Install dependencies

sudo apt install cmake git


git clone https://github.com/Rezonality/mutils
cd mutils
chmod +x prebuild.sh
chmod +x config.sh
chmod +x build.sh

Qt (required is using build_qt.sh)

# for Qt/Demo support
sudo apt install qt5-default 
# Adapt to your installation path
set QT_INSTALL_LOCATION="/usr/include/x86_64-linux-gnu/qt5"


git clone https://github.com/Rezonality/zep
cd zep
# Optional argument are qt and imgui 
./config.sh ( qt | imgui )


Build instructions and testing on mac needs an update; consult the travis build to see examples


Type CTest --verbose in the build folder to run unit tests.


This sample uses SDL for the window setup, and ImGui for the rendering, or Qt.

SDL2: Media/Window Layer
SDL2 is used to get a window on the screen in a cross platform way, and for OpenGL to generate a Context.

ImGui: 2D GUI
ImGui is a great 2D User interface for 3D applications

Rezonality - "Rez"
Rezonality -
  • CMake Error at extensions/CMakeLists.txt:7 (find_package):   By not providing

    CMake Error at extensions/CMakeLists.txt:7 (find_package): By not providing "FindSDL2.cmake"

    Describe the bug While building on windows using : cmake -G "Visual Studio 16 2019" -A x64 -DZEP_FEATURE_CPP_FILE_SYSTEM=1 -DBUILD_IMGUI=0 -DBUILD_TESTS=0 -DBUILD_DEMOS=0 .. This error pops up. To Reproduce Steps to reproduce the behavior:

    1. Clone the repo
    2. On the command line, run the above command
    3. See the error


    F:\Dropbox\Tech\production\ppc\zep\build>cmake -G "Visual Studio 16 2019" -A x64 -DZEP_FEATURE_CPP_FILE_SYSTEM=1 -DBUILD_IMGUI=0 -DBUILD_TESTS=0 -DBUILD_DEMOS=0 ..
    -- CMakeLists: Zep
    -- Build Type:
    -- Selecting Windows SDK version 10.0.18362.0 to target Windows 10.0.18363.
    -- The CXX compiler identification is MSVC 19.27.29111.0
    -- The C compiler identification is MSVC 19.27.29111.0
    -- Detecting CXX compiler ABI info
    -- Detecting CXX compiler ABI info - done
    -- Check for working CXX compiler: C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.27.29110/bin/Hostx64/x64/cl.exe - skipped
    -- Detecting CXX compile features
    -- Detecting CXX compile features - done
    -- Detecting C compiler ABI info
    -- Detecting C compiler ABI info - done
    -- Check for working C compiler: C:/Program Files (x86)/Microsoft Visual Studio/2019/Community/VC/Tools/MSVC/14.27.29110/bin/Hostx64/x64/cl.exe - skipped
    -- Detecting C compile features
    -- Detecting C compile features - done
    -- System: Windows-10.0.18363
    -- Compiler: MSVC
    -- Arch:
    -- TARGET_PC
    CMake Error at extensions/CMakeLists.txt:7 (find_package):
      By not providing "FindSDL2.cmake" in CMAKE_MODULE_PATH this project has
      asked CMake to find a package configuration file provided by "SDL2", but
      CMake did not find one.
      Could not find a package configuration file provided by "SDL2" with any of
      the following names:
      Add the installation prefix of "SDL2" to CMAKE_PREFIX_PATH or set
      "SDL2_DIR" to a directory containing one of the above files.  If "SDL2"
      provides a separate development package or SDK, be sure it has been

    -- Configuring incomplete, errors occurred!

    Desktop (please complete the following information):

    • OS: Win 10, VC 19
  • Using Zep with

    Using Zep with "international" keyboard (key code remapping?)

    Describe the bug I'm trying to use Zep with ImGui, inside the Cinder framework (which has its own keymapping but internally uses GLFW). My keyboard is Spanish, which means that some keys (notably {}[]|@#~\) are accessed differently than on an standard US keyboard. On a Spanish keyboard, these require pressing the AltGr key before pressing another key to get the desired character (e.g. bracket/brace). I've managed to handle these keys, by writing a keypress handler (in Cinder) that remaps/translates input keyboard events into simpler events for ImGui. For example, pressing AltGr+´ should give me an open brace {, but in Zep it thinks control was pressed, since AltGr behaves like Ctrl+Alt. So I remapped things in this case:

        auto& io = ImGui::GetIO();
        io.KeyCtrl = io.KeyAlt = false;

    And that seems to work...in my program, in the Zep editor, I get a { inserted (if I don't modify KeyCtrl, then I get a <C+{> inserted). But I'm still having problems with other keys (ones that don't require AltGr), such as + or ^. These don't require modifier keys but are different key codes than a US keyboard.

    I notice you have special handling for SDL (ref: ZEP_USE_SDK in editor_imgui.h) and I'm wondering if I might need something similar to handle my (Cinder/GLFW) codes. I'm looking through the code but am not very familiar with it yet...can you give me any pointers on how I should be approaching this? i.e. how to fix it in the "correct" way? Thanks!

    Desktop (please complete the following information):

    • OS: Windows 10 Pro
    • Visual Studio 2019 (C++17)
  • console_imgui.h does not compile

    console_imgui.h does not compile

    Describe the bug https://github.com/Rezonality/zep/blob/master/include/zep/imgui/console_imgui.h does not compile due to:

    Line 32: No matching constructor for initialization of 'Zep::ZepEditor_ImGui' Line 36: No member named 'SetFlags' in 'Zep::ZepBuffer' Line 51 and 52: No member named 'EndLocation' in 'Zep::ZepBuffer'

    To Reproduce

    1. Try to compile project and use the console_imgui.h
  • LineWidget Input Processing

    LineWidget Input Processing

    This is more of a question, apologies. What is the mechanism that routes mouse events to Widgets in a buffer? For example, the FloatSlider never seems to actually hit its mousedown callback.

    As long as I'm pushing my luck with questions: how would you go about translating mouse coordinates of a click to a displayed buffer line?

    I love Zep but it is very good at making me feel very dim. :)

  • Minor missing functionality from Vim `%` handling

    Minor missing functionality from Vim `%` handling

    Describe the bug This new feature is fantastic, thanks. One minor thing: Zep does not find matching parens when they're on a previous line (unlike Vim).

    To Reproduce Steps to reproduce the behavior:

    For the following buffer:

     y) more stuff

    More important: If the cursor is at the start of the second line (or on the y) when the % motion is pressed, Zep doesn't jump back to find the matching opening parenthesis on line 1 (in Vim it would).

    Less important: If the cursor is in more stuff it doesn't jump anywhere in Vim when % is pressed (there is no following "match char" on that line), but in Zep it jumps back to the earlier ) on the previous line.

    Expected behavior

    For the first (more important) case, pressing % should jump back to the ( after function on line 1.

    For the second case, the cursor shouldn't move anywhere.

    Technically, the behaviour of % should be:

    Find the next item in this line after or under the cursor and jump to its match. (from :help %)

    Example unit tests:

    // Existing cases
    CURSOR_TEST(motion_percent_next_bracket, "a ( b \na ) b", "%", 2, 1);
    CURSOR_TEST(motion_percent_next_then_first_bracket, "a ( b \na ) b", "%%", 2, 0);
    CURSOR_TEST(motion_percent_first_bracked_inner, "a ( b \na ) b", "lll%", 3, 0); // no motion (changed from 2,0)
    CURSOR_TEST(motion_percent_inner_bracket_step, "a ( b () \na ) b", "ll%", 2, 1);
    // New cases
    CURSOR_TEST(motion_percent_previous_line, "a(x,\n y) z\nf()", "j%", 1, 0); // jump back to previous line
    CURSOR_TEST(motion_percent_no_jump, "a(x,\n y) z\nf()", "j3l%", 3, 1); // no jump
    CURSOR_TEST(motion_percent_next_line, "a(x,\n y) z[\nf()]", "j3l%", 3, 2); // jump to next line closing `]`
  • Multiple changes / feedback

    Multiple changes / feedback

    I've recently integrated Zep into my project PCSX-Redux, replacing ImGuiColorTextEdit out. While doing so, I've done numerous little fixes and changes to Zep. I could create one issue / pull request per change I've done, but I'd like to avoid bombarding you with issues and PRs. But if you'd rather me doing so, please let me know and I'll gladly extract my changes in individual Pull Requests / issues.

    My current list of changes are in https://github.com/nicolasnoble/zep/commits/40ff9f8c0fd0a159249c4f9d6e0ebcdee81dce1e, and here's a small list of issues / enhancements I've done:

    General comments

    ImGui integration

    The current ImGui input code assumes:

    • no other window will try to read keyboard input (and so ignores widget focus)
    • SDL and "something else?" for input, which doesn't work for all ImGui backends, such as GLFW.

    As a result, when using GLFW as the backend, typing the key a on the keyboard (which is ascii 0x41 for glfw) will result in sending a function key instead: https://github.com/Rezonality/zep/blob/435a218ebf3e7a4e1067ca9fa630b7b2473bcad8/include/zep/imgui/editor_imgui.h#L26

    I've created my own ZepEditor_imgui class, but my opinion is that the code should probably offer one Editor class per possible backend, like SDL, GLFW, etc.


    (additionally, this new code uses ImGui::IsWindowFocused to discard keyboard input that aren't directed towards the Zep widget)

    Lua parser

    The syntax.cpp file references lua keywords, but doesn't register any parser for it. The Lua syntax is significantly different from base C that it wouldn't work properly anyway, so I wrote a Lua parser that seems somewhat correct, or at least, good enough:



    DPI scaling is currently invalid

    The current code assumes a single DPI scale, that never changes. In reality, this doesn't work, because users may change DPI on their current screen, or even have multiple monitors, all with different DPIs. As a result, DPI-aware code needs to be able to react to DPI change events. This is in essence what I've done here: https://github.com/nicolasnoble/zep/commit/97b4365ff9300abc64801e3dc96b27693bc9228a

    The code probably should use a signal to be broadcasted, in order to fully invalidate fonts and other painting, but I wasn't sure.

    This is likely an API breaking change in its current state, due to the DPI scale being removed from the constructor.

    (additionally, there is a dead, never used variable here:) https://github.com/Rezonality/zep/blob/435a218ebf3e7a4e1067ca9fa630b7b2473bcad8/include/zep/editor.h#L445

    Line number in Standard Mode

    The current code has a DisplayMode enum that's never assigned to any value: https://github.com/Rezonality/zep/blob/435a218ebf3e7a4e1067ca9fa630b7b2473bcad8/include/zep/window.h#L252

    As a result, this check is always true, regardless of the editor mode: https://github.com/Rezonality/zep/blob/435a218ebf3e7a4e1067ca9fa630b7b2473bcad8/src/window.cpp#L1028

    I've fixed this by using a new virtual on the mode: https://github.com/nicolasnoble/zep/commit/249dafe3c169ec6a632e9f9efd92a2458b629966

    gap_buffer.h doesn't compile

    More specifically, this part of the template: https://github.com/Rezonality/zep/blob/435a218ebf3e7a4e1067ca9fa630b7b2473bcad8/include/zep/gap_buffer.h#L152 references rhs.buffer where rhs is but a size integral.

    Fix: https://github.com/nicolasnoble/zep/commit/a38f2f71cc29f99bddb7ac104ab65da1a381fd0a

    Paste isn't using the system's clipboard

    All the paste commands use the " register for the slice of text to insert, but only registers * and + are assigned from the system's clipboard. Fix: https://github.com/nicolasnoble/zep/commit/68fb6ada6c0cd858006ba273308f9e5f388f9c7d


    Syntax parser

    I've overhauled a bit the base syntax parser to handle numbers and comments a bit better. I'm still not totally happy with it, but I think it's a general improvement over the base code. The new file is at https://github.com/nicolasnoble/zep/blob/main/src/syntax.cpp

    I have no idea how this fares on the Lisp mode however.

    Mouse clicks to move the cursor

    As a simple Quality of Life, I've added a mouse cursor and the ability to move the keyboard cursor to it: https://github.com/nicolasnoble/zep/commit/fe2a6a4fc36213fa49c717efbb1f5c04514b1048

    The feature is probably awkward as it doesn't actually send a command to move the cursor, which doesn't necessarily update the buffer status properly. Also affects all modes, not just standard. Mouse dragging to select would be a plus.

    I think I'd rather move this to commands, using a new encoding for mouse events, similar to the <C-v> pattern.

    Standard mode selection deletion

    This feels a lot more natural than only having Ctrl-x working: https://github.com/nicolasnoble/zep/commit/03b1598b754c320df8958fbf9f240cdf88b23d6c

    Ctrl-a "select all" in Standard mode

    This also feels a lot more natural: https://github.com/nicolasnoble/zep/commit/40ff9f8c0fd0a159249c4f9d6e0ebcdee81dce1e

  • utf8::unchecked::iterator should not derive from std::iterator

    utf8::unchecked::iterator should not derive from std::iterator

    Describe the bug When compiling on VS2019 (with C++17), there are warnings from the inheritance of std::iterator by utf8::unchecked::iterator, with the following message:

    1>C:\Users\...\zep\include\zep\mcommon\utf8\unchecked.h(220,40): warning C4996: std::iterator<std::bidirectional_iterator_tag,utf8::uint32_t,ptrdiff_t,utf8::uint32_t *,utf8::uint32_t &>: warning STL4015: The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17. (The <iterator> header is NOT deprecated.) The C++ Standard has never required user-defined iterators to derive from std::iterator. To fix this warning, stop deriving from std::iterator and start providing publicly accessible typedefs named iterator_category, value_type, difference_type, pointer, and reference. Note that value_type is required to be non-const, even for constant iterators. You can define _SILENCE_CXX17_ITERATOR_BASE_CLASS_DEPRECATION_WARNING or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to acknowledge that you have received this warning. (compiling source file ..\zep\src\buffer.cpp)

    To Reproduce Steps to reproduce the behavior:

    1. Build a project using Zep under VS2019 (compiling in C++17 mode).
    2. See warnings (not hugely serious, but should be cleaned up at some point).

    Expected behavior No warnings.

    Desktop (please complete the following information):

    • OS: Windows 10 Pro
    • Version 10.0.19043
    • VS2019 version 16.8.3
  • Simple ImGUI example

    Simple ImGUI example

    It seems it should be easier to integrate this great editor into an ImGUI project.

    • There is https://github.com/cmaughan/imgui/blob/b562cfeb14060a6b3b0c8189c3e16ea1ffa01070/imgui_demo.cpp#L219 Which is a much more simple integration example then the imgui demo. However it is outdated as ZepEditor expects more arguments for example.

    • There is a define ZEP_SINGLE_HEADER_BUILD which is there for convenience I guess. However it requires a config_app.h (single line file on my system?). Could be very handy to use without building a lib first.

    • The provided ImGui demo has quite some dependencies which (I'm not sure) are not really needed.

    • From what I read in the code the imgui demo uses freetype font rendering, I guess that's optional?

    Perhaps the example can be updated as it seems more straightforward?

  • A method to advertise font changes to ZepWindow?

    A method to advertise font changes to ZepWindow?

    Is your feature request related to a problem? Please describe. When the font changes, horizontal character spacing is not recomputed because m_charCacheDirty is never set to true again. Vertical spacing and about everything else seems OK.

    Describe the solution you'd like Maybe just a method in ZepWindow that sets m_charCacheDirty to true?

    Additional context Initial rendering in ImGui: image After loading a larger or a smaller font: image image

  • cmake errors + fix?

    cmake errors + fix?

    Just trying out the library on a Linux system gives some errors. Running this on Debian bullseye with cmake 3.18.4:

    $ cmake ..
    -- CMakeLists: Zep
    CMake Error at /usr/share/cmake-3.18/Modules/CMakeDetermineSystem.cmake:99 (message):
      Could not find toolchain file:
    Call Stack (most recent call first):
      CMakeLists.txt:32 (project)
    CMake Error: CMake was unable to find a build program corresponding to "Unix Makefiles".  CMAKE_MAKE_PROGRAM is not set.  You probably need to select a different build tool.
    CMake Error: CMAKE_CXX_COMPILER not set, after EnableLanguage
    CMake Error: CMAKE_C_COMPILER not set, after EnableLanguage
    -- Configuring incomplete, errors occurred!

    Not sure why it's looking for vcpkg? Is this really needed?

    Running with cmake .. -DBUILD_QT=OFF -DBUILD_DEMOS=OFF gives:

    CMake Error at CMakeLists.txt:79 (configure_package_config_file):
      Unknown CMake command "configure_package_config_file".

    So I guess CMakeLists.txt needs


    which then succeeds. :+1:

  • Fix the ImGui build.

    Fix the ImGui build.


    • ZepBuffer::SetFlags is now ZepBuffer::SetFileFlags (changed in 47fa8e2165b4425829eb28a089ed6bd29ad7e6c2)
    • ZepMode::Begin requires a window argument (introduced in 1364206ce38ff0c9a1264867f50ff926c3b26ae8).

    Type of change

    • [x] Bug fix (non-breaking change which fixes an issue)
  • 'A' to 'E' letter keypresses emit F8-F12 when no SDL is used

    'A' to 'E' letter keypresses emit F8-F12 when no SDL is used

    With demo application somewhat ported to use sokol (https://github.com/floooh/sokol) instead of SDL. Key defintions from include/zep/imgui/editor_imgui.h seem to clash with 'A'-'E' range. Pressing 'A' gives <F8> and so on...

    Maybe it's just needs a #ifdef guard, like i did: https://github.com/alcz/zepeditor/commit/db6895e66a3289216340d3943677a88395bb7cef

    Working with keymaps feels like a huge job.

    Thanks for such a cool editor with dear imgui support.

  • ZepPath::replace_extension truncates character before dot.

    ZepPath::replace_extension truncates character before dot.

    Describe the bug ZepPath::replace_extension truncates the character before the dot if the extension provided contains a dot.

    To Reproduce

    auto path = Zep::ZepPath{"/path/to/myfile.o8"};

    Behavior path in the above is modified to /path/to/myfil.ch8 instead of /path/to/myfile.ch8.

    Expected behavior path in the above is modified to /path/to/myfile.ch8 instead of /path/to/myfil.ch8.


        ZepPath& replace_extension(const std::string& extension)
            size_t dot = m_strPath.find_last_of(".");
            if (dot != std::string::npos)
                m_strPath = m_strPath.substr(0, dot - 1) + extension;
                m_strPath += extension;
            return *this;

    Believe the dot - 1 to be the issue. Unless my expectations are just wrong. :)

  • How is Zep's current input handling done?

    How is Zep's current input handling done?


    Zep is looking like a really nice, embeddable, editor. Thanks for working on it.

    I'm trying to embed Zep in my Vulkan-based app, to use it as the Console input and the Log output window. I'm using ImGui for the ui. I tried embedding it by following this file: https://github.com/Rezonality/zep/blob/master/demos/demo_imgui/main.cpp

    I think that file may be out of date. I managed to get Zep to display a line of text, but can't get it to respond to inputs. This line, in the above demo file, calls a method which doesn't exist to handle input. zep.spEditor->HandleInput();

    What's the current way to do input management with Zep?

    Btw, not a huge deal, but I notice that Zep displays an extra line # that it's not in the source text.



  • How to customize the theme colours and background

    How to customize the theme colours and background

    Discussed in https://github.com/Rezonality/zep/discussions/80

    Originally posted by totalgee February 25, 2022

    1. Is there a way to customize the theme without changing the Zep library itself? I'd like to modify the colours for keywords or identifiers (taking one of the default themes and tweaking a few values).
  • Potential problems with Zep::ZepTheme::GetColor() API change

    Potential problems with Zep::ZepTheme::GetColor() API change

    Describe the bug When integrating a more recent version of Zep, I was hit by a bug where my whole editor went black. This did not happen when compiling in debug mode, which made it a bit tricky to track down. I finally realised it was because Zep::ZepTheme::GetColor now returned a Zep::NVec4f const & (as opposed to a Zep::NVec4f previously), so when overriding that method I had to make sure I did not return a reference to a temporary because the compiler was (rightfully) assuming I did not care about the returned value.

    I studied bf53e9cb9563d3d67d555bf32bf2a4c1d8f993d2 and could not understand a reason behind returning a reference. From what I found so far, the returned value is always eventually copied to a Zep::Nvec4f.

    This is of course a very common mistake that every C++ programmer should avoid, but it is easily overlooked and I realise that the copiler did not warn me about it.

    Also there is currently a real problem in ZepTheme due to that: since SetLightTheme() allocates more colors than SetDarkTheme(), any value returned by GetColor may be invalidated by a call to SetLightTheme().

    My personal issue is solved but I’m still suggesting reverting the API change to avoid surprises for other users.

  • Line wrapping and step down problem

    Line wrapping and step down problem

    Describe the bug With word wrap on, sometimes stepping down with 'j' at the end of a wrapped line will not step to the next line and get 'stuck'

    To Reproduce Create a long line and an empty line after it, make the editor small so that the text wraps, and use J to step down.

Vimb - the vim like browser is a webkit based web browser that behaves like the vimperator plugin for the firefox and usage paradigms from the great editor vim.

Vimb - the vim like browser is a webkit based web browser that behaves like the vimperator plugin for the firefox and usage paradigms from the great editor vim. The goal of vimb is to build a completely keyboard-driven, efficient and pleasurable browsing-experience.

Dec 30, 2022
EyeLog Can Record And Steal Consecutive Keystrokes (and much more) That The User Enters On A Device
EyeLog Can Record And Steal Consecutive Keystrokes (and much more) That The User Enters On A Device

What This EyeLog EyeLog Is A Keylogger Can Record And Steal Consecutive Keystrokes (and much more) That The User Enters On A Device How To Setup EyeLo

Dec 28, 2021
This is a plan9 port of the vim editor.

This is a plan9 port of the vim editor.

Nov 30, 2022
Simple text editor in C++ - Simple editor built upon kilo editor.

GUMBO editor Simple editor built upon kilo editor. Still big work in progress although this is just fun side project to learn more C/C++. From 0.0.2->

Sep 15, 2021
C/C++ language server supporting multi-million line code base, powered by libclang. Emacs, Vim, VSCode, and others with language server protocol support. Cross references, completion, diagnostics, semantic highlighting and more

Archived cquery is no longer under development. clangd and ccls are both good replacements. cquery cquery is a highly-scalable, low-latency language s

Jan 2, 2023
Sokoban written in C using VIM in Termux. A very easy game

Ncurses Sokoban Installation and how to use apt update apt install git git clone https://github.com/JyanJohn/sokoban cd sokoban make ./soko

Nov 15, 2021
A "mini" implementation of vim :3

minivim info A "mini" implementation of vim :3 It uses VT100 escape characters (I will implement ncurses in the future probably). P.S. I know they are

Jun 9, 2022
CRC32 slice-by-16 implementation in JS with an optional native binding to speed it up even futher

CRC32 slice-by-16 implementation in JS with an optional native binding to speed it up even futher. When used with Webpack/Browserify etc, it bundles the JS version.

Aug 4, 2021
Fully resizing juce peak meter module with optional fader overlay.
Fully resizing juce peak meter module with optional fader overlay.

Sound Meter Juce peak meter module with optional fader overlay. by Marcel Huibers | Sound Development 2021 | Published under the MIT License Features:

Nov 22, 2022
New version of the well known ESP32 Radio. Now optional I2S output!

ESP32Radio-V2 New version of the well known ESP32 Radio. Now optional I2S output! Compile time configuration in config.h. Do not forget to upload the

Dec 28, 2022
DLL Exports Extraction BOF with optional NTFS transactions.
DLL Exports Extraction BOF with optional NTFS transactions.

DLL Exports Extraction BOF What is this? This is a Cobalt Strike BOF file, meant to use two or three arguments (path to DLL, and/or a third argument [

Nov 9, 2022
STFT based multi pitch shifting with optional formant preservation in C++ and Python

stftPitchShift This is a reimplementation of the Stephan M. Bernsee smbPitchShift.cpp, a pitch shifting algorithm using the Short-Time Fourier Transfo

Dec 16, 2022
Elk is a tiny embeddable JavaScript engine that implements a small but usable subset of ES6
Elk is a tiny embeddable JavaScript engine that implements a small but usable subset of ES6

Elk is a tiny embeddable JavaScript engine that implements a small but usable subset of ES6. It is designed for microcontroller development. Instead of writing firmware code in C/C++, Elk allows to develop in JavaScript. Another use case is providing customers with a secure, protected scripting environment for product customisation.

Jan 8, 2023
Golang bindings of Sciter: the Embeddable HTML/CSS/script engine for modern UI development
Golang bindings of Sciter: the Embeddable HTML/CSS/script engine for modern UI development

Go bindings for Sciter Check this page for other language bindings (Delphi / D / Go / .NET / Python / Rust). Attention The ownership of project is tra

Dec 23, 2022
A dependency free, embeddable debugger for Lua in a single file (.lua or .c)
A dependency free, embeddable debugger for Lua in a single file (.lua or .c)

debugger.lua A simple, embedabble debugger for Lua 5.x, and LuaJIT 2.x. debugger.lua is a simple, single file, pure Lua debugger that is easy to integ

Dec 31, 2022
Filter driver which support changing DPI of mouse that does not support hardware dpi changing.

Custom Mouse DPI Driver 하드웨어 DPI 변경이 불가능한 마우스들의 DPI 변경을 가능하게 하는 필터 드라이버 경고: 해당 드라이버는 완전히 테스트 되지 않았습니다 Install 해당 드라이버는 서명이 되어있지않습니다. 드라이버를 사용하려면 tests

Sep 23, 2022
Diwali Lighting using ESP32 with OTA update support

OTA_ESP32_8x50_ws2811 Diwali Lighting using ESP32 with OTA update support! This code is meant to drive 8 neopixel chains through separate pins. Being

Feb 5, 2022
Jittey - A public domain text editor written in C and Win32
Jittey  - A public domain text editor written in C and Win32

Jittey (Jacob's Terrific Text Editor) is a single-file basic text editor written in pure C and Win32, there is no real reason to use it, but it

Dec 15, 2022
Super simple code editor designed for students.
Super simple code editor designed for students.

HamroCode Super simple code editor designed for students of Nepal. Language Supported JavaScript C C++ QBASIC Downloading Click Here Demo Created & Ma

Mar 30, 2021