Forem: taku25

UNL.nvim Update: Shifting from LSP to DB-based Completion & Preparing for UE6/Verse Unreal Engine development in Neovim.

taku25 — Mon, 06 Apr 2026 08:25:30 +0000

Intro

I've been a bit quiet lately due to my day job, but I’m excited to share a long-awaited update! This release brings a fundamental architectural shift to the UNL.nvim ecosystem.

🚀 The Big Change: Moving from LSP to DB-based Completion

To solve performance bottlenecks and remove the strict dependency on compile_commands.json, I’ve completely migrated the completion engine to a DB (Database) managed system.

Why?: It offers much faster, more flexible completion without being tethered to a static compile_commands.json.
Current Status: While there might be some rough edges, it works perfectly for my personal daily development.

✨ New Feature: Module Creation (`UDEV create_module`)

This feature was born from a community Pull Request. It significantly streamlines the process of adding new modules to your UE project.

Huge thanks to notfound4 for this amazing contribution!!

🔧 Bug Fixes

Improved stability with several fixes:

Resolved server-side memory leaks.
Fixed bugs in the File Watcher.
Various minor stability improvements.

🛠️ Looking Ahead: UE6 and Verse Language Support

With the whispers of Unreal Engine 6 growing louder, I’ve started working on tree-sitter-verse, built from the language specs up.

The migration to a DB-based system is a strategic move to eventually provide official Verse language support. I’ll be refining the command structure and DB schema while we wait for the dawn of UE6.

[Neovim x UE] Optimization via Rust Server & .uasset Binary Parsing (Weekly Update)(2026/02/16)

taku25 — Mon, 16 Feb 2026 13:42:58 +0000

Introduction
Here is this week's update!
Unlike previous posts, I don't have flashy screenshots of new UI features to show off today. Instead, this update focuses on significant under-the-hood optimizations and foundational improvements using Unl-server (Rust).
Here are the main changes:

Full Migration of Syntax Parsing to the Server I have moved all syntax parsing logic—previously handled by Neovim (Lua) using Tree-sitter or Regex—entirely to the Unl-server side.
- Removed Dependencies: This removes the Tree-sitter dependency from the plugin suite (except for syntax highlighting). If you primarily use LSP for syntax highlighting, you no longer need to install treesitter-unreal-cpp.
- Improved Accuracy: Running Tree-sitter on the server side (Rust) allows for faster and more accurate syntax analysis than ever before.
.uasset Parsing: Moving to Binary Analysis I have completely overhauled the method for parsing .uasset files, moving from simple string searches (using ripgrep) to direct binary parsing via Rust.
- Supported Versions: UE 5.3 - 5.7
- Higher Precision: This significantly improves the accuracy of retrieving Children and References. Specifically, UFUNCTION references, which were previously difficult to capture, can now be retrieved reliably. ⚠️ Note: Currently, this analysis data is not persisted to the database. Therefore, there may be a short wait time after startup while the parsing completes. Please keep this in mind.
Enhanced Picker API Extensibility I have extended the Picker functionality to allow for more flexibility. You can now easily add custom pickers beyond the defaults provided. By setting an arbitrary function in the picker model, you can create and integrate your own custom pickers. For detailed specifications and usage, please refer to the README below: Unified Picker API - UNL.nvim README Summary: Performance Improvements By offloading these heavy tasks to the server (Rust), the CPU load on Neovim itself has decreased, resulting in a much smoother and more comfortable editing environment. Please update to the latest version and enjoy a lighter, faster Neovim x UE development experience! taku25/unrealdev.nvim If you like this project, giving the repository a ⭐️ (Star) would mean the world to me (and make me do a little happy dance)! Happy Neovim x UE life!!

Making Neovim a Lightweight Unreal Engine IDE: Implementing Blazing Fast Completion without LSP

taku25 — Mon, 09 Feb 2026 06:24:21 +0000

Hi everyone! I’m the creator of the UnrealDev.nvim suite, a project dedicated to turning Neovim into the ultimate IDE for Unreal Engine (UE) development.

After migrating our core logic to the Rust-based "unl-server", I've shifted focus to a major milestone: Improving the built-in completion engine.

🛠 The "Why": Moving Beyond LSP

For a long time, I relied on LSPs like clangd. However, UE development—especially on Windows—poses unique challenges:

LSP Overhead: Waiting for indexers and compilation in massive UE projects can be frustratingly slow.
The "Clang Database" Headache: Generating and maintaining .compile_commands.json or .rsp files often conflicts with standard UBT (Unreal Build Tool) workflows.

I love Neovim for its speed. It felt wrong that "heavy" IDEs like Rider were sometimes more responsive than my Neovim setup. So, I decided to build a database-driven completion engine that doesn't rely on a full LSP stack.

🚀 Performance Showcase

Take a look at the custom completion in action:

This is powered entirely by unl-server and our custom DB. It currently supports:

Standard variable declarations.
auto keyword type resolution.
UE-specific templates like TObjectPtr<T>.
*Return values of functions (e.g., Getters/Setters) — *

⚙️ How it works

When completion is triggered, the current buffer and cursor position are sent to unl-server. The server infers the class context and returns candidates via MessagePack-RPC.

I’m currently using taku25/blink-cmp-unreal, but since the core logic resides on the server, it can be adapted to other completion engines easily.

❤️ Growing Community

I’m thrilled to see the community growing! Huge thanks to notfound4 for the amazing contributions and PRs lately.

Your stars and contributions keep this project moving forward. Let’s make Neovim the best place to build Unreal Engine games!

GitHub: taku25/UnrealDev.nvim

Unrealdev.nvim Update: Migration to Rust Server and MessagePack-RPC for High-Performance UE Development 2026/02/02

taku25 — Tue, 03 Feb 2026 01:14:49 +0000

Introduction
Hello everyone, I’m taku25, the developer of unrealdev.nvim.
After two intense weeks of development, I’m excited to announce the largest architectural overhaul in the history of this project.
I have introduced several breaking changes regarding cache formats in the past, but this update is a complete "heart transplant" for the plugin's core. While I apologize for the disruption, this new foundation is designed for long-term stability—I don't expect any more major architectural shifts for the foreseeable future.

The Core: Moving to "unl-server" (Rust) The biggest change is the migration of all heavy-lifting tasks—including SQLite database management and C++ parsing via tree-sitter—to a dedicated external server written in Rust, called unl-server. Previously, UEP.nvim handled the DB directly. Now, unl.nvim acts as the primary gateway, retrieving data directly from the Rust server using MessagePack-RPC. By using a binary format instead of plain text, we’ve laid the groundwork for extremely low-latency communication. unl.nvim, which started as a simple base library, has now truly become the "heart" of the unrealdev.nvim ecosystem.
Command Changes & Auto-Server Start With the shift in responsibility, server management has moved from UEP to UNL.
- Command Migration:
- UEP refresh/start/stop → Deprecated
- UNL refresh/start/stop → New To improve the developer experience (DX), I’ve implemented an Auto-Server Start feature (auto_server_start, enabled by default). When you launch Neovim or cd into a directory containing a .uproject file, the Rust server will automatically spin up in the background. No more manual setup is required.
Real-time Project Monitoring The server does more than just fetch data; it now includes a file system watcher. It monitors your project files in real-time, ensuring that the symbol database is always up-to-date as you code. You no longer need to worry about stale indices while navigating your C++ classes. What's Next? While core commands have been debugged, I'm aware there are still minor bugs and areas where performance can be further optimized. Starting this week, I will focus on:
- System Stability and Performance Tuning.
- Developing a Custom Completion Engine that leverages our internal database instead of relying solely on external LSPs. Thank you for your continued support as we build the ultimate Unreal Engine development environment for Neovim!

[UnrealDev.nvim] Enhanced IDE Integration & Custom Actions (Weekly Update 2026/01/24)

taku25 — Sat, 24 Jan 2026 05:24:54 +0000

Hello everyone! I am developing a suite of Neovim plugins for Unreal Engine development called taku25/unrealdev.nvim.

Here are the updates for this week! The main focus is on strengthening bi-directional integration with IDEs (like Rider) and enhancing UNX.nvim features.

1. UEP.nvim: Enhanced IDE Integration

Auto-start Neovim Server

I've updated UEP start to automatically launch the Neovim server.
This allows you to seamlessly open files in your currently running Neovim instance directly from your IDE (Rider, Visual Studio, etc.).

You can configure the server name in the UEP.nvim options:

server = {
  enable = true,
  name = "UEP_nvim", -- You can change the name here
},

Note for Windows Users:
On Windows environments, .pipe is automatically appended to the specified server name. Please keep this in mind when connecting from external tools.

Setup Example: Open in Neovim from JetBrains Rider

By adding an "External Tool" in Rider, you can jump to Neovim via the right-click menu.

Go to Settings -> Tools -> External Tools.
Add a new tool with the following settings:
Program: nvim.exe
Arguments: --server \\.\pipe\UEP_nvim --remote-send "<C-\><C-n>:e $FilePath$<CR>:$LineNumber$<CR>zz"

What does this argument do?
It sends a command to Neovim to: "Exit Insert Mode -> Open the file -> Go to the specific line -> Center the screen."

(Insert your screenshot of Rider settings here)

2. UEP.nvim: Open IDE from Neovim (`open_ide`)

Conversely, I added a feature to open the file you are currently editing in Neovim directly in your IDE using UEP open_ide.

This command is fully configurable in your config. It defaults to Rider, but you can easily set it up for Visual Studio or VS Code.

ide = {
  -- For Rider (Default)
  open_command = "rider --line {line} \"{file}\"", 

  -- Example for VS Code
  -- open_command = "code -g {file}:{line}",

  -- Example for Visual Studio (Adjust the path to devenv as needed)
  -- open_command = "devenv /edit {file} /command \"Edit.GoTo {line}\"", 
},

3. UNX.nvim: Project Tree & Diff Enhancements

I also added some convenient features to UNX.nvim, which handles the UI.

Open in IDE from Project Tree

You can now press <C-o> on a file in the project tree to open it in your configured IDE (using the open_ide setting mentioned above).

Diff View Support

Pressing D on the project tree now displays the standard Neovim VCS diff. This is great for quickly checking changes.

Custom User Functions (Keymaps)

If the standard diff is hard to read, or if you want to run specific commands on a file, you can now define custom functions in your keymaps.

Define them in your config like this:

keymaps = {
  custom = {
    -- Key = Function to execute
    ["<leader>p"] = function(node)
      -- 'node' contains file info for the current line
      if node and node.path then
        print("Selected file path: " .. node.path)
      end
    end,

    -- You can also define it as a named action (for future extensions)
    ["<C-z>"] = {
      action = function(node)
        vim.notify("Custom action for: " .. (node.name or "unknown"))
      end,
      desc = "My custom notification"
    }
  }
}

What's Next?

That’s it for this week's updates.

For next week and beyond, I plan to work on expanding the Database (DB) features and implementing detailed analysis using Rust + Tree-sitter. My goal is to create a robust completion system that understands the specific structures of Unreal Engine, without relying solely on LSP.

Although it is still experimental, I have already started introducing a Rust program called scanner into UNL.nvim.

I will continue to add more features to make Unreal Engine development in Neovim the best experience possible!

Happy coding!

Bringing Neovim Closer to Rider: Auto-Generation & Tree Enhancements (Weekly Update)

taku25 — Sat, 17 Jan 2026 08:34:26 +0000

Here are the updates for this week.
Along with fixing some persistent database-related bugs, I've focused on implementing convenient features found in JetBrains Rider—specifically "Create Definition" and "Create Implementation"—into UCM.nvim.

Neovim is getting one step closer to a full IDE experience for Unreal Engine development!

🚀 UCM.nvim: Seamless Definitions & Implementations

I’ve automated the boilerplate code writing that usually requires manual switching between header and source files.

UCM create_impl
Executing this command on a function definition in a header file automatically inserts the implementation template into the corresponding source (.cpp) file.
A key feature is that if the function is marked with override, it automatically generates the Super::Function() call as well.
UCM create_decl
This performs the reverse of create_impl. Executing it on a function implementation in the source file adds the definition to the header. It also supports signature updates, such as changes to arguments.

UCM add_struct While classes are typically managed as "one class per file," there are often times when you want to quickly add a struct to a header. This command provides a wizard where you can simply select a name and parent struct to insert the appropriate USTRUCT definition right at your cursor.

Refactoring New File Creation
UCM new_class: Dedicated command for creating new class files.
UCM new_struct: Dedicated command for creating new struct files.
I refactored the internal logic of UCM new to properly handle both classes and structs independently.

🌲 UNX.nvim: Reducing File Tree Friction

I've improved the usability of the file tree to reduce friction during navigation.

Tree State Persistence Unreal Engine project hierarchies tend to be very deep. Reopening folders every time I restarted Neovim was tedious, so I added the ability to save and restore the tree's open/close state.
UNX focus I implemented a feature to focus the file tree on the currently edited file. This is extremely useful when you want to create a new file in the same directory as the one you are currently working on—you can instantly locate your position in the tree.

🔍 UEP.nvim: Enhanced Navigation

UEP structs Implemented a feature to display a list of structs and jump directly to their definitions.

Conclusion

That wraps up this week's changes.
With the addition of implementation/definition auto-generation and the struct wizard, I feel that Neovim has reached a level where it can be my primary battlefield for editing code.

Looking ahead, I'm exploring ways to integrate Neovim with IDEs like Rider.
For example, it would be amazing to instantly open a file hitting a breakpoint in Rider directly in Neovim, or conversely, open the file being edited in Neovim inside Rider. If I can achieve this seamless interaction, I think it will create the ultimate development environment. I'm currently researching the technical feasibility of this workflow.

Turning Neovim into a UE5 IDE: File Watching & Architecture Shifts (Weekly Update 2026-01-09)

taku25 — Fri, 09 Jan 2026 04:23:51 +0000

Happy New Year! 🎉 It's 2026, and I'm kicking off the year with a renewed focus: making Neovim the ultimate IDE for Unreal Engine development.

Here is this week's progress report. We have some major architectural changes and new features that bring us significantly closer to that "IDE-like" experience.

Polishing the SQLite Migration 🧹
Following the recent migration to SQLite, I've squashed a number of bugs that popped up. The foundation is now much more stable, ensuring a smoother experience overall.
UNX: Ditching the Cache for a Pure File Tree 🌳
Previously, the file tree implementation was heavily tied to unl-neotree, relying on a cached tree structure. This week, I completely overhauled this.

The Change: I moved away from the cache-dependent architecture to a pure file tree approach using a custom structure for UNX.

The Benefit: We no longer rely on stale data. If you add or remove files externally (e.g., via Windows Explorer), the tree can now handle those changes immediately without waiting for a cache rebuild. It only displays the information strictly necessary for UE development, keeping it lightweight.

New UNX Features:

N Key (Create File): You can now create simple files directly in the tree!

Why this matters: Previously, you could only create classes via wizards. Now, if you have a header file and just want to quickly add the corresponding .cpp source, you can simply hit N.

R Key (Force Refresh): Added the ability to manually force a tree update/redraw.

One Step Closer to an IDE: UEP start 🚀 This is the highlight of the week.

My goal is to make Neovim function as a "lightweight IDE" for UE. To achieve this, I implemented UEP start (alias: UDEV start_project), which replaces the old manual UEP refresh workflow.

How it works: Instead of manually refreshing, you run UEP start. This kicks off a background process that:

Watches VCS Revisions: Smartly detects git changes.

Monitors Files with vim.uv: It watches the project folder for any file changes using Neovim's built-in Libuv loop.

The Result: Changes are detected instantly. The cache updates file-by-file in real-time, meaning commands like UEP files reflect the current state of your project immediately. No more manual toggling!

Note: If you want to stop the background monitoring, simply run UEP stop (UDEV stop_project).

That's it for the first update of 2026. I'm excited to keep pushing the boundaries of what Neovim can do for Game Devs this year.

Happy coding!

UnrealDev.nvim Update: Switching to SQLite for Blazing Fast Performance

taku25 — Mon, 29 Dec 2025 08:54:58 +0000

Just in time for the end of the year, I've released a major update for UnrealDev.nvim!

Previously, UnrealDev.nvim (and its core, UEP.nvim) used JSON files to cache project information. However, for large Unreal Engine projects, the file I/O overhead for reading and writing massive JSON files became a noticeable bottleneck.

To solve this, I have completely migrated the caching backend to SQLite.
This change significantly improves performance, making file navigation and project analysis faster than ever.

🔧 Key Changes & Installation

1. New Dependency: `sqlite.lua`

With this update, the following plugin is now required:

kkharji/sqlite.lua

⚠️ Important Note for Windows Users:
sqlite.lua requires sqlite3.dll to function.
If you install SQLite via package managers like winget, it might only provide the .exe without the necessary .dll.

Solution:

Download the Windows binaries (containing the DLL) directly from the SQLite Download Page.
Configure the path in your init.lua:

-- Example: Set path to sqlite3.dll
vim.g.sqlite_clib_path = "C:\\Users\\username\\path\\to\\sqlite3.dll"

2. Updated `:checkhealth`

I've updated the health check to verify the SQLite status. If everything is set up correctly, you should see something like this:

UnrealDev:                                                                  ✅

UnrealDev Dependencies ~
- ✅ OK Executable 'fd': Found (File finder)
- ✅ OK Executable 'rg': Found (Ripgrep text searcher)
- ✅ OK UNL.nvim: Installed (Core Library & Utilities)
- ✅ OK Plugin 'kkharji/sqlite.lua' found.
- ✅ OK Path configured: C:\Users\taku3\AppData\Local\Programs\sqlite\sqlite3.dll
- ✅ OK SQLite is working correctly! (In-memory DB test passed)
...

🚀 Command Unification

To streamline the workflow, several specific commands have been deprecated and merged into the main commands.

Deprecated: :UEP config_files, :UEP program_files, :UEP config_grep, :UEP program_grep
Merged into: :UEP files, :UEP grep

The command arguments have been updated to support a new mode parameter:

:UEP files [scope] [mode] [deps_flag]
:UEP grep  [scope] [mode] [deps_flag]

You can now specify the file type using the mode argument (default is source).

Examples:

" Find Config (.ini) files in Runtime modules
:UEP files runtime config

" Find source files for Programs (Tools) within the Game project
:UEP files game programs

" Find Shader (.usf/.ush) files in the Engine
:UEP files engine shader

This allows for flexible filtering by combining scope and mode.

Note: Commands like :UEP module_files remain separate to keep the argument logic simple for module-specific actions.

UnrealDev.nvim Weekly Update: Performance Tuning & The Road to SQLite 🚀(2025/12/19)

taku25 — Thu, 18 Dec 2025 15:03:54 +0000

Happy Friday, developers! 👋

This week has been a bit hectic with my day job, so the changelog is shorter than usual. However, I managed to squeeze in some crucial Quality of Life (QoL) improvements and bug fixes that should make your daily Unreal Engine development in Neovim smoother.

More importantly, I've finally decided on the direction for the next major optimization phase. Let's dive in!

⚡ Performance Improvements

UNX: Faster Symbols View

The Symbols View in UNX (the explorer UI) previously tried to fetch and display the entire parent class inheritance tree by default. While useful, this caused noticeable lag when opening large files in Unreal Engine projects.

Change: To prioritize speed, the parent class tree is now OFF by default.
New Feature: You can toggle the parent class information on demand by pressing p inside the Symbols View.
Note: This keybinding is configurable via config.keymaps.action_toggle_parents.

Now, the view opens instantly, and you only pay the performance cost when you actually need that deep inheritance context.

✨ New Features

UNX: Quickly Favorite the Current File

I found myself frequently wanting to add the file I'm currently editing to my Favorites list without having to search for it in the tree or picker.

New Command: Added :UNX favorite_current (and :UDEV favorite_current).
Behavior: This command toggles the favorite status of your active buffer instantly.

Bug Fixes

UNX Favorites: Fixed a bug where the UI wouldn't refresh immediately after adding a file to favorites. It now updates in real-time.
UCM Symbols: Fixed an issue where jumping to a selected symbol in the Unreal Class Manager (UCM) wasn't working correctly.

🗺️ Roadmap: The Road to SQLite

This is the part I'm most excited about.

Unreal Engine projects are massive. Parsing thousands of header files and managing class relationships using text-based caches or large JSON files has its limits regarding startup time and memory usage.

I have decided to migrate the heavy lifting of caching (files, class definitions, inheritance maps) to SQLite.

Progress so far:

I've started implementing the database layer in UNL.nvim (the core library).
The goal is to have UEP.nvim connect to a local SQLite database for blazing-fast lookups.

Once this is implemented, commands like UEP files, UEP enums, and generating inheritance trees should become significantly faster and more robust.

That's it for this week! Although development might slow down slightly due to work, the migration to SQLite is my top priority for the next major update.

As always, feedback and contributions are welcome!

Happy coding! 🎮 vim

UnrealDev

[UnrealDev.nvim] Weekly Update (Dec 12, 2025): UNX Enhancements & New Project Creation

taku25 — Fri, 12 Dec 2025 14:00:21 +0000

Introduction

This week, I focused mainly on enhancing UNX.nvim, cleaning up commands, and adding the ability to access features directly via commands without needing to open the UI (Explorer).

1. UNX: Features & Improvements

Pending List View & `UNX pending_list` Command

I added a feature to display a list of files currently being edited in your VCS (Version Control System). This is incredibly effective when you want quick access to the files you are currently working on.

Unpushed List View & `UNX unpushed_list` Command

This feature is currently for environments using Git (since Perforce pushes immediately upon commit).
When you are stacking small commits for a single task, there are times when you want to see "a list of files modified in this session but not yet pushed." This list allows you to quickly access and navigate to those files.

Favorites List View & `UNX add_favorites` / `UNX favorites_list` Commands

I added a bookmarking function for frequently used files and folders.

To Add: Select the target in UNX and press the b (bookmark) key, or use the add_favorites command to select files via a Picker (multiple selections supported).
To Remove: Press the b key again on the target file within the UNX Favorites tree to remove it from the list.

Folder Action: Files Picker

Pressing the F key on a folder in the UNX tree now opens a picker that allows you to search and select files contained within that folder.

2. UCM: Symbols Command Added

The "symbols list of the currently opened file," which was previously displayed on UNX, has been made independent as a UCM.nvim command.
Executing the UCM symbols command allows you to cross-search symbols from both the Header (.h) and Source (.cpp) files via a picker and jump directly to their definitions.

3. UEP: Support for New Project Creation

Previously, the plugins assumed an existing project. Now, the new_project command enables the creation of new Unreal Engine projects directly from Neovim.
To support this, UNL (Unreal Launcher)'s find_engine has been updated internally to search for installed Engine versions.

4. ULG: Tabbed Log View

Previously, unreal log and build log were displayed using split buffers. To align with UNX's tab support, ULG logs have also been changed to a tab format.
You can switch the display using the Tab key within the log window.

Reflections: Dogfooding in Production

I'm happy to feel that the plugins are reaching a level where they work without issues not only in personal projects but also in massive, real-world work projects.
However, as the project scale increases, I'm starting to feel some performance weight, so I've been thinking a lot about optimization lately.

[Tip] For Windows Users using UBT

Here is a note on generating compile_commands.json using UnrealBuildTool (UBT) with GenerateClangDatabase.

This command has a quirk where it rewrites .rsp files that shouldn't need modification. As a result, if you try to run a normal build afterwards, the timestamp update triggers a Full Rebuild (including the Engine), causing massive wait times.

To avoid this, I recommend specifying the GameProject's Debug configuration when generating compile_commands.json.

You likely use DebugGame or Development configurations for actual development (since the Debug configuration makes the Engine itself too heavy), but specifying the Debug configuration solely for command definition generation helps prevent accidental full rebuild accidents.

Neovim Unreal Engine: P4 Support, Macro Wizards, and Context-Aware Docs! 🚀(2025/12/04)

taku25 — Thu, 04 Dec 2025 03:16:07 +0000

I realize I'm building plugins for a "niche within a niche"—using Neovim for Unreal Engine C++ development. But honestly? It's becoming surprisingly capable.

This week, I shipped some massive updates to the UnrealDev.nvim ecosystem. From Perforce integration to a wizard for generating UPROPERTY macros, here is what’s new!

📦 1. UnrealDev.nvim

Health Checks for Peace of Mind

Added `:checkhealth UnrealDev`

I added a health check command to verify that your Unreal Engine development environment is set up correctly.

Since nvim-treesitter parsers don't always auto-update with plugin managers, things can sometimes get out of sync. If something feels off, just run this command to troubleshoot instantly.

🌲 2. UNX.nvim (Explorer)

Finally... Perforce (P4) Support!

You can't talk about Unreal Engine development without mentioning Perforce. It's the industry standard, and until now, UNX only supported Git.

With this update, P4 status is now integrated into the file tree!

Status Icons: Visualizes P4 states (Add, Edit, etc.) directly in the explorer.
Auto-Checkout: If you try to modify a read-only file, a dialog will pop up asking if you want to check it out.

Say goodbye to those annoying "File is read-only" errors! 👋

🛠️ 3. UCM.nvim (Code Actions)

Speeding up Includes & Macros

📋 `:UCM copy_include[!]`

Tired of manually typing relative paths for #include? This command calculates the correct include path for a C++ class and copies it to your clipboard.

Auto-Resolution: Run this on MyActor.cpp, and it generates #include "Actor/MyActor.h".
:UCM copy_include: Copies the include path for the current file.
:UCM copy_include!: Lets you fuzzy-search for a class name and copies its include path.

⚡ `:UCM specifiers[!]` (The Macro Wizard)

Writing UPROPERTY, UFUNCTION, or UCLASS macros by hand is tedious. This wizard handles it for you.

Normal Mode (:UCM specifiers):

1.  Select the macro type (e.g., `UPROPERTY`).
2.  Multi-select specifiers (e.g., `EditAnywhere`, `BlueprintReadWrite`).
3.  Inserts the full macro `UPROPERTY(EditAnywhere, ...)` at your cursor AND copies it to the clipboard.
4.  **Smart Cursor:** If you pick something like `Category=""`, the cursor automatically jumps between the quotes.

Append Mode (:UCM specifiers! with bang):
- Perfect for editing existing macros.
- It skips the wrapper and only inserts the specifiers (e.g., EditAnywhere) at your cursor position.

🔍 4. UEP.nvim (Project Provider)

Smarter Navigation & Docs

File & Shader Enhancements

Config/Shaders Visibility: Fixed an issue where UEP tree wasn't showing Config or Shaders directories.
Virtual Paths: Added support for virtual include paths in .ush / .usf files. open_files can now jump straight to them.
:UEP shaders[!] [Scope]: A new command to search and open shader files quickly.

C# Config Navigation

:UEP build_cs[!]:
- Without !: Instantly opens Build.cs for the current module.
- With !: Lists all Build.cs files in the project to choose from.
:UEP target_cs[!]:
- Without !: Lists project Target.cs files.
- With !: Includes Engine targets in the search.

🌐 `:UEP web_doc[!]` (Context-Aware Docs)

Opens the official Unreal Engine documentation in your browser. The best part? It automatically detects your project's UE version and opens the correct page.

Without !: Searches the docs for the word under your cursor.
With !: Lets you select a class from your project to open its documentation.
- Note (Experimental): If the plugin can't guess the direct URL, it gracefully falls back to a site search.

Conclusion

This week was all about "Quality of Life" improvements. I focused on fixing those small frictions that made me miss my heavy IDE.

Honestly, I'm finding myself opening Rider less and less these days. (Maybe I just forgot the Rider shortcuts? 🤔... nah, Neovim is just getting that good!)

If you have any feature requests or ideas, let me know in the comments or issues. And if you find these plugins useful, a Star ⭐️ on UnrealDev.nvim would make my day!

Happy Hacking! 💻✨

Neovim x Unreal Engine: Visualizing Config Inheritance & Jumping to Super Classes [Weekly Update]

taku25 — Fri, 28 Nov 2025 02:18:06 +0000

Introduction

Hello! I’m a developer who is frantically building plugins to make Neovim the most comfortable environment for Unreal Engine development.

My goal is to make Neovim function just like a full-fledged IDE (like Rider or Visual Studio) for UE5.
In this week's update, I've added a feature to instantly visualize the complex "Config (.ini)" hierarchy—a headache for every UE developer—and navigation features to boost coding speed.

⚠ Important: 1. Update `tree-sitter-unreal-cpp`

This step is mandatory to use the new features.
I have updated the parser to improve the accuracy of Unreal C++ analysis. However, due to how Treesitter works, you need to manually update the revision number in your configuration.

For features like AActor class analysis, the Symbols View, and the new Goto Super (described below) to work correctly, please overwrite your plugin config with the following settings (The Wiki has also been updated):

 { 
   'nvim-treesitter/nvim-treesitter',
    branch = "main",
    config = function(_, opts)
      vim.api.nvim_create_autocmd('User', { pattern = 'TSUpdate',
        callback = function()
          local parsers = require('nvim-treesitter.parsers')
          parsers.cpp = {
            install_info = {
              url  = 'https://github.com/taku25/tree-sitter-unreal-cpp',
              -- Please update from the old hash (89f34...) to the one below:
              revision  = '67198f1b35e052c6dbd587492ad53168d18a19a8', 
            },
          }
          parsers.ushader = {
            install_info = {
              url  = 'https://github.com/taku25/tree-sitter-unreal-shader',
              revision  = '26f0617475bb5d5accb4d55bd4cc5facbca81bbd',
            },
          }
       end
     })
     -- (Other installation settings...)
  end
}

2. [Killer Feature] Config Explorer: Escape from Config Hell

The Unreal Engine Config (.ini) system is powerful but incredibly complex.
It starts with Engine/Config/Base.ini, then Project/Config/DefaultEngine.ini, overrides by WindowsEngine.ini, and even further overrides by DeviceProfiles...

"In the end, what is the actual final value of this parameter?" "Where was it overwritten?"
Have you ever gotten lost tracking this down?

To solve this, I implemented the Config Explorer.

Features:

Hierarchy View: Displays config values relevant to your project in a tree structure organized by platform.
Visualizing Inheritance: It merges and displays not just Default settings, but also platform-specific settings (Windows, Android, iOS) and even Device Profiles (like Android_Low).
History Tracking: You can track the history of a parameter: "In which file, on which line, and how was it changed (Overwritten, Added, Deleted)?"
Jump to Source: Select a history entry to instantly jump to the definition line in the original .ini file.

↑ It analyzes the actual project INIs and displays the final value and override history in one shot.

3. Implement Virtual: Auto-generate Overrides

When overriding a virtual function in a parent class in C++, copying and pasting the signature between header files is tedious.
I've implemented the "Override function..." feature found in Rider and VS into Neovim.

It traverses the inheritance chain of the current class and lists available virtual functions.
Simply pick one from the list, and it adds the declaration (with override) to the header and copies the implementation code (with Super::Call) to your clipboard.

4. Goto Super Definition / Implementation

"How was this function implemented in the parent class?"
To find out, we used to have to grep or trace the LSP hierarchy. Now, it's just one command.

:UDEV goto_super_def: Jump to the parent class function definition (Header).
:UDEV goto_super_impl: Jump to the parent class implementation (Source).

It recognizes the function name at the cursor, intelligently searches the inheritance tree, and jumps.

5. Symbols View Optimization (Lazy Initialization)

As projects grew larger, the initialization cost of the Symbol Tree (Class/Function view) started to become noticeable.
In this update, I completely refactored the architecture to perform analysis and initialization only at the moment it is needed (Lazy Loading).
This significantly improves Neovim startup time and file opening response.

6. Find Module: Reverse Lookup for Dependencies

When writing C++ in Unreal, a common friction point is editing Build.cs. You often know the class name you want to use (e.g., UNiagaraComponent), but you forget which module needs to be added to PublicDependencyModuleNames.

:UDEV find_module: This command opens a picker listing all classes, structs, and enums. When you select one, it identifies the module it belongs to (e.g., "Niagara") and copies the module name to your clipboard, wrapped in double quotes.

You can then simply paste it directly into your Build.cs. It’s a simple utility, but it saves a lot of context switching and documentation searching.

7. Other Improvements

Small but useful fixes:

UCM switch: Added support for file paths in Engine/Classes.
UEP find_parents: Added support for UObject (making the inheritance tree much clearer).
UEP tree: Fixed a bug where project files inside Plugins were hidden.
UNL: Added .ini file parsing capability and standardized the C++ parser logic.

Conclusion

With this week's updates, Neovim is getting closer to a true "Unreal Engine Specialized IDE."
I believe the Config Explorer, in particular, is a unique feature not standard even in commercial IDEs.

If you find this useful or want to support the project, please check out the repositories.
While the number of Clones is increasing (yay!), the Star count is still a bit lonely (lol). Your Stars give me the motivation to develop the next feature!

[Links to Repositories]

UnrealDev.nvim (Integration Plugin): https://github.com/taku25/UnrealDev.nvim
UEP.nvim (Analysis Engine): https://github.com/taku25/UEP.nvim
UNX.nvim (UI Explorer): https://github.com/taku25/UNX.nvim

Forem: taku25

UNL.nvim Update: Shifting from LSP to DB-based Completion & Preparing for UE6/Verse Unreal Engine development in Neovim.

Intro

🚀 The Big Change: Moving from LSP to DB-based Completion

✨ New Feature: Module Creation (UDEV create_module)

🔧 Bug Fixes

🛠️ Looking Ahead: UE6 and Verse Language Support

[Neovim x UE] Optimization via Rust Server & .uasset Binary Parsing (Weekly Update)(2026/02/16)

Making Neovim a Lightweight Unreal Engine IDE: Implementing Blazing Fast Completion without LSP

🛠 The "Why": Moving Beyond LSP

🚀 Performance Showcase

⚙️ How it works

❤️ Growing Community

Unrealdev.nvim Update: Migration to Rust Server and MessagePack-RPC for High-Performance UE Development 2026/02/02

[UnrealDev.nvim] Enhanced IDE Integration & Custom Actions (Weekly Update 2026/01/24)

1. UEP.nvim: Enhanced IDE Integration

Auto-start Neovim Server

Setup Example: Open in Neovim from JetBrains Rider

2. UEP.nvim: Open IDE from Neovim (open_ide)

3. UNX.nvim: Project Tree & Diff Enhancements

Open in IDE from Project Tree

Diff View Support

Custom User Functions (Keymaps)

What's Next?

Bringing Neovim Closer to Rider: Auto-Generation & Tree Enhancements (Weekly Update)

🚀 UCM.nvim: Seamless Definitions & Implementations

🌲 UNX.nvim: Reducing File Tree Friction

🔍 UEP.nvim: Enhanced Navigation

Conclusion

Turning Neovim into a UE5 IDE: File Watching & Architecture Shifts (Weekly Update 2026-01-09)

UnrealDev.nvim Update: Switching to SQLite for Blazing Fast Performance

🔧 Key Changes & Installation

1. New Dependency: sqlite.lua

2. Updated :checkhealth

🚀 Command Unification

UnrealDev.nvim Weekly Update: Performance Tuning & The Road to SQLite 🚀(2025/12/19)

⚡ Performance Improvements

UNX: Faster Symbols View

✨ New Features

UNX: Quickly Favorite the Current File

Bug Fixes

🗺️ Roadmap: The Road to SQLite

Progress so far:

[UnrealDev.nvim] Weekly Update (Dec 12, 2025): UNX Enhancements & New Project Creation

Introduction

1. UNX: Features & Improvements

Pending List View & UNX pending_list Command

Unpushed List View & UNX unpushed_list Command

Favorites List View & UNX add_favorites / UNX favorites_list Commands

Folder Action: Files Picker

2. UCM: Symbols Command Added

3. UEP: Support for New Project Creation

4. ULG: Tabbed Log View

Reflections: Dogfooding in Production

[Tip] For Windows Users using UBT

Neovim Unreal Engine: P4 Support, Macro Wizards, and Context-Aware Docs! 🚀(2025/12/04)

📦 1. UnrealDev.nvim

Added :checkhealth UnrealDev

🌲 2. UNX.nvim (Explorer)

🛠️ 3. UCM.nvim (Code Actions)

📋 :UCM copy_include[!]

⚡ :UCM specifiers[!] (The Macro Wizard)

🔍 4. UEP.nvim (Project Provider)

File & Shader Enhancements

C# Config Navigation

🌐 :UEP web_doc[!] (Context-Aware Docs)

Conclusion

Neovim x Unreal Engine: Visualizing Config Inheritance & Jumping to Super Classes [Weekly Update]

Introduction

⚠ Important: 1. Update tree-sitter-unreal-cpp

2. [Killer Feature] Config Explorer: Escape from Config Hell

3. Implement Virtual: Auto-generate Overrides

4. Goto Super Definition / Implementation

5. Symbols View Optimization (Lazy Initialization)

6. Find Module: Reverse Lookup for Dependencies

7. Other Improvements

Conclusion

✨ New Feature: Module Creation (`UDEV create_module`)

2. UEP.nvim: Open IDE from Neovim (`open_ide`)

1. New Dependency: `sqlite.lua`

2. Updated `:checkhealth`

Pending List View & `UNX pending_list` Command

Unpushed List View & `UNX unpushed_list` Command

Favorites List View & `UNX add_favorites` / `UNX favorites_list` Commands

Added `:checkhealth UnrealDev`

📋 `:UCM copy_include[!]`

⚡ `:UCM specifiers[!]` (The Macro Wizard)

🌐 `:UEP web_doc[!]` (Context-Aware Docs)

⚠ Important: 1. Update `tree-sitter-unreal-cpp`