Over 15 years with Vim, I transitioned from user to OSS contributor and plugin creator. This keynote reflects on my nvim-cmp journey, sharing insights into text completion across Vim, VSCode, and LSP. Meanwhile, I'll candidly discuss FOSS challenges—maintenance limits and burnout—touching on my current perspectives.

hrsh7th is a Web frontend engineer based in Japan. With around 15 years of experience using (n)vim, he's the author of popular plugins like vim-vsnip and nvim-cmp. As a Web frontend engineer, he has a strong interest in enhancing editor-based workflows and user experience for daily development.

I've implemented a new feature called TabPanel and would like to share the story behind it — including the motivation for its development, design considerations, and technical implementation. In this talk, I'll cover: - Motivation & Background: Why TabPanel was added and what problems it solves. - Design & Implementation: How TabPanel works under the hood, including design decisions and challenges encountered. - Usage & Configuration: An introduction to the basic usage and configuration of TabPanel.

rbtnn is what you might call an SIer in Japan. These days, his main role is team management, so he doesn't get to write code as often. That said, he worked across the stack throughout his career—from server-side and client-side development to embedded systems—making him a so-called full-stack engineer. Vim has been his primary text editor for nearly 15 years, and he uses it to write code in almost any programming language. He's contributed to Vim itself several times in the past.

As a vim beginner, I've always felt the steep learning curve of vim was intimidating. However, with the advent of AI-powered coding assistants, the barriers to entry for various technologies, including vim, have significantly lowered. This talk explores how AI is democratizing vim adoption. In this session, I will share: - My journey from vim-curious to vim user through AI assistance - How to build nvim configuration with AI guidance step by step - Essential plugins and configurations for beginners using AI tools - How to leverage AI to understand complex vim concepts and commands - Creating beginner-friendly documentation and README.md/CLAUDE.md with AI help - Common pitfalls and how AI can help avoid them This talk is aimed at vim-curious developers and beginners who want to overcome the traditional vim learning curve by leveraging modern AI tools to make their Step 0 into the vim world more approachable.

It's exciting to start using Neovim with the thought, "Using Neovim is cool!" Many beginners want to improve their Neovim. They often start by copying settings recommended on websites or YouTube. That's fine and can be useful, but it's still using someone else's Neovim as long as you're just following recommendations. To truly make Neovim your own, you need to understand what you can achieve by configuring it yourself. Many beginners simply don't know what's possible through configuration. That's why I'll introduce some of those possibilities. In this talk, I'll show you an overview of Neovim features and settings using a nice plugin, mini.nvim. This plugin is a collection of many useful modules that you can mix and match according to your needs. By exploring these modules, you'll gain insight into what Neovim can do and what features you might need. More importantly, you'll learn to think about what you want to achieve, how to figure out the best way to do it, and how to write the right settings for that. This process helps you develop your engineering skills. You'll also experience the joy of growing your configuration. It's not just useful, it's really fun! Let's get started with your own Neovim, featuring mini.nvim! Disclaimer: I'm not the author of mini.nvim. I'm a big fan of it and use it in my Neovim configuration.

In the year 202X, the world was ravaged by AI-assisted coding. Functions were generated automatically. Code reviews ran on natural language prompts. Developers stopped writing code and became... prompt engineers. Text editors disappeared — or so it seemed. But Vim survived. I’m no exception. These days, the first draft of code often comes from an AI, and I rarely need to write loops or simple routines myself. But while I’m writing less, I’m spending a lot more time reading. Why is this function written this way? What role does this design play in the bigger picture? Who made this change — and why? Even in an age where machines write the code, understanding the flow, the structure, and the reasoning still falls to us. And that’s when I realized: Vim is absurdly good at seeing. Split windows for parallel perspectives. Mode switching to shift context. Jumps and searches to trace the flow. Viewing code alongside its history. Custom mappings to navigate between layers of abstraction. With tools like Fall, Fern, and Gin, Vim transforms from just a code editor into a thinking interface. In this talk, I’ll share why I still use Vim in a time where writing code is no longer the main act. As more of our code is machine-generated, how we look at it — and what we pay attention to — becomes more important. I’ll walk through how I use Vim to “see,” through the lens of Fall, Fern, and Gin. The machine can write. But I still need to see. You’re no longer writing. And yet—you’re still watching.

Neovim users get benefits of beautiful syntax highlighting with Tree-sitter. However, Tree-sitter can do much more than just syntax highlighting. Once you understand it is actually an incremental parsing library, you may come up with various ways to enhance your text edit experience. I will introduce some of my favorite use cases and their implementations (tree-sitter parser, query, and Neovim plugin). Audience can try out these examples themselves, or use them as a starting point for their own creative ideas. Here are some of the use cases I will cover: * Select and edit syntactically meaningful regions * select a specific kind of nodes as text objects (e.g. function, class, etc.) * select a node that includes the cursor position with a help of easymotion-like labelling * Add extra highights to your code * change the background color of code blocks in markdown files * emphasize URL paths in literal string * and more * syntax-aware code folding * context-aware key mappings based on the node under the cursor Also, I would like to introduce `treesitter-ls`, a tree-sittere-powered language server. Although this is currently a work in progress, it is worth introducing as it potentially provides the power of tree-sitter to non-Neovim users.

In recent years, the rise of generative AI has only heightened the importance of writing skills. In this presentation, I'll explain how Vim's rich editing features make it particularly suitable for writing, and how customization can enhance your writing experience. I'll demonstrate this with practical examples from my own workflow, then share my method for quickly exporting text outside of Vim.

Vimmers are the kind of people who want to use Vim anytime, anywhere — and that doesn’t change even in a cloud-native world. I’ve been working on a way to run the Vim editor inside Eclipse Che, a cloud-native IDE. It’s not fully production-ready yet, but in this talk, I’d like to share how it works and discuss the challenges I’ve faced.

Vim’s dot (.) command is deceptively simple—it repeats the last change. But beneath this minimalism lies one of Vim’s most powerful ideas: editing as a repeatable, structured action. Dot doesn’t just replay—it expresses Vim’s philosophy of reusable, composable editing. In this session, we’ll explore how dot works under the hood: how edits are recorded and replayed, and why some actions are repeatable while others are not. We'll then move into practical techniques for designing dot-friendly edits using operators, motions, and text objects. We’ll also look at why many plugin actions don’t support dot repeat by default, and how tools like repeat.vim and repeat#set() help restore consistency. By understanding how to align plugin behavior with Vim’s model, we can extend dot’s elegance even in custom workflows. Ultimately, this talk is not just about using . more effectively—it’s about writing edits and workflows that align with it, unlocking a deeper level of speed, clarity, and composability in your Vim usage.

You already know Vim registers aren’t just clipboards. But when asked: “Why didn’t it go into ""0""?”, “What’s rotating in ""1–9""?”, or “Why did the thing I just copied disappear?” — can you explain why? Vim’s register system is both powerful and subtle. It tracks what gets saved, when it's overwritten, and which register each operation touches—often silently. Understanding this system is key to avoiding accidental loss and enabling intentional, reusable editing workflows. In this talk, we’ll break down how each register works: ""0"", ""1–9"", ""a–z"", ""="", ""_"", ""*"" and others. You’ll learn practical techniques for designing safer edits, preserving state, and even injecting dynamic content from expressions or shell commands. This session will help you stop guessing—and start thinking in registers.