Subscribe to watch future live streams here:
YouTube Live Stream Channel
Live streams typically happen on Saturday at 4pm GMT
10x Live Streams: Stewart Lynch talks about the development of the 10x C++ Editor. Deep diving into the code and system design, as well as profiling and optimisations. Stewart also takes questions on anything related to the 10x Editor.
General development update. v1.0 is getting very close now! Reaching ZBR. Stabilising build. Working on Website, user guide, payment system and registration system. Launch date (sort of) announced. Updates since last stream. Preprocessor fixes and speedups. Fixed to window dragging and docking. Fixes for use with FancyZones. VS project loading times speedup. Zoom context menu item. Parsing all of stl and windows headers. ExecuteVSCommand() python API command. Tabs/spaces indenting in python. Auto-generation of website doc pages. Fixes to VisualStudioEnvBat setting. F1 for internet search. Lots of fixes/improvements to 10x workspaces. Remember open files and unsaved file titling for 10x_notepad.
Optimising 10x startup times. File system caching. Overlapped IO. Identifying read stalls. Cost of opening lots of small files. File writes. Allocating memory stalls. Benefits of IO on binary files instead of text. The package system and threaded reads. Moving entire initailise to another thred, and then back again. New precaching system. Sequential reads in file system. IOThreadMain thread. Moving precache and package reads off the sequential IO thread. Hack to short-cut the Windows window fade in.
Update on the latest changes. Explanation of how the new additional include paths works and allows goto-def on Windows functions. Multi-line macro parsing. Explanation on HybridArray and related optimisations. Goto-def on defined out args. Preprocessed line hoverbox now works of #if lines. Support for __VA_ARGS__ in macros. Resolving of goto-def on typedefs. Change to the undefine keyword colouring. Support for lambda copy captures. Auto reloading of workspace/project files. Automatically syncing debug settings from VS. Word-wrap indenting. 10XLogEnv.exe bug finally fixed.
Detailed look at the new python 3.10 integration. Parsing of multi-line macro calls. New highlighting in scroll bar feature. Why Python? RemedyBG integration with named pipes. Static linkage to python caused problems. Building python from source. Files that need to be installed. How to use and install python packages. PyWin32 example. Quick look at vim.py and how to use 10x API.
Feature Complete! 110 updated, 532 changes since last stream. Brief overview of changes since last update. Telemetry update. Growth in daily use time. Ethics of recording telemetry. Opt in. Unique hash id for each user. Using 10x to develop 10x. 3 tricks to make that easier. VS debugger syncing. New line ending handling. Need to support files with mixed line endings. Using word wrap and collapse regions. Detailed explanation of how the word-wrap and collapse regions were implemented, with minimal speed and memory overhead. Fast implementation of GetIndexOf() for arrays. What's next. Bugs to fix for v1.0 release.
General development update. In-depth look at the new syntax highlighting system. Why I designed it the way I did. Why a new system was needed. How the new system works with the parser syntax highlighting. Description of the syntax highlighting file format. When to use REGEX(), WORD() and TEXT() rules. Why there is a special case rule for block comments. How to use regex groups. An in-depth look at the syntax highlighting parser code. Why the order of the rules matters. Comparing the speed of re2 and std::regex. Taking a look at the threading. Explanation of regex backtracing. Immediate updating when the file is saved. Discussion of how much stl I use in 10x (not much). Plan for word wrapping and code folding.
General development update. Overview of the main bugs and features that have been added in the last 7 weeks. New vertical ruler setting. Tab pinning. Nested namespace support. "Open As Text" feature. Parser.Extensions setting. Optimisation of large multi-cursor rect-selects. Colour scheme improvements. Default fonts now bundled in installer. New 10x logo and icons. Window dragging from anywhere in the title bar. Parser.DefinedOutBrightness setting. Complex statements in define conditionals. Fixes for Unreal parsing. Function pointer support. IndentMode per file and per workspace.
General development update. Overview of 5 Years of 10x development. Telemetry update. Roadmap and update on feature complete and 10x release. Update on Issues list. Find in files changes since last time, X3 faster. Some of the bugs fixed since last stream; colour schemes, font rendering FindSymbol fixes. Explanation of the new docking system. Removal of drag bars for docked panels. change to panel splitting for docked panels. Dragging of multiple panels at once ideas. New settings autocomplete, and improved font setting. Key mappings autocomplete. Explanation of how to bind python functions to keys. Explanation of the difference between 10x Commands and python API commands. Updating to the latest python version to allow adding of python packages. Github Issues cleanup and new labels.
General development update. Memory build released, 75% memory reductions with no reported issues. New website. Playlists and descriptions for live streams. Roadmap update. Windows 11 transparent borders bug. Changed shortcut key for multi-cursor. New find in files feature. UI designer demo. Walkthrough of the find in files code. Threading and the StringArray class.
Memory part III. Update on memory savings. New memory graphs. Comparison of different compression libraries; zlib, lz4, zstd. More data now compressed. Detailed MemPro breakdown. New LogMemoryStats command to log memory in 10x output window. Description of fixes to wastful allocators. Stopping workspace search and parser panels from decompressing half the codebase. Storing of symbol colouring to avoid having to decompress. Optimisations to find symbol panel. Workspace Search memory optimisation for ASCII files. More threading problems with compression. Optimisation to preprocessor include lists. Re-working of array and hashmap containers. General Q&A.
Memory part II. An update on how the memory optimisations are progressing. The decision to use compression instead of streaming. Statistics/graphs on memory reductions so far. Optimisations to the parser read cache time. Showing read cache threading and compressing in FramePro profile. Explanation of some of the problems encountered with compressing and threading. Deadlocks, races and recursive locking. Explanation of recursive shared lock and why it is needed. Improvements to switching of configs. Plans for more memory reductions and what still needs to be done.
Memory Part I: "We need to talk about memory". Update on preprocessor. Preprocessor released in main build. Switching of config and updating of preprocessed lines. Why 10x is using so much memory. The plan to reduce memory. Detailed breakdown of where the memory is going (lines, tokens etc). Workspace search memory. Possible solutions: compression or streaming from disk. Mempro memory breakdown.
The incremental parser. Improvements to how the parser now reuses information from previous parses when editing code. Explanation of how code edits now result in fewer re-parses of other files. Explanation of how the parser tokenizes and builds up a symbol tree as it parses. Keeping the symbol tree in sync with changing code. Fixing up of references when symbols are added/removed. How the preprocessor copes with incremental changes. Update on the preprocessor.
Preprocessor Part II. Update on the preprocessor. Reading defines from the Visual Studio projects using msbuild. Adding stringification and concatenation to preprocessor. Fixes to preprocessor conditionals. Analysis of parse times and extra memory from the preprocessor and how they were optimised. Optimisations to the lexer. Resolving of include paths. Hash map optimisations. NUMA node optimisation. Analysis of VMem memory stats. Profiling using Visual Studio sampling profiler. Reduction of allocations. Profiling memory using MemPro.
Preprocessor Part I. Update on the C++ Preprocessor. Limitations of single file parsing ignoring headers. Why it's important for the preprocessor to know about includes. Explanation of how includes are parsed. How the three passes work in the parser. How the preprocessor pass parses. Macro substitutions and keeping track of original and preprocessed code. Preprocessor conditional parsing and defining code out. Showing the python test scripts for the preprocessor.
Explanation of Workspaces: opening Visual Studio projects in a workspace, folder workspaces, 10x workspaces. Creating a 10x workspaces. Explanation of the Sync Files checkbox. Addition include paths setting. Build settings. Converting folder workspaces to 10x workspaces. Virtual (grouping) folders. Adding references to other 10x workspaces.
General Q&A. Questions on preprocessor. Perser for other languages. Ports to other platforms. Talking about latest changes. Support for stl. Auto indentation. Code formatting. Non-client area rendering on Windows.
Optimising 10x startup times. Profiling using FramePro. Walkthrough of the FramePro profile talking about the main things that take time on startup. Font load times. Talking about potential optimisations. File IO performance and pack files. Serialisation of UI data.
*** Audio cuts out a couple of times for a few minutes in this stream, once at 15 mins and again at 29 mins, but it does come back ***
Introduction to all the main 10x features. This is a good video to start with. Demo of loading large projects. Demo of Workspace Search (FastFind), OpenFile. Demo of parser features, such as autocomplete, goto-def, find references, find symbol, rename symbol. File encodings. Multi-cursor. Window docking. Building projects. Syncing breakpoints with Visual Studio debugger. Colour schemes. Changing settings and key bindings. Python scripting.
Demo of the new multi-cursor editing. An explanation of how the text encoding works in 10x. BOM headers, what text encoding is and how it works. Explanations of ASCII, ANSI, Unicode, utf8, code pages. Explanation of special glyphs not supported by the font. Explanation of the ref-counted WString class. Brief overview of the syntax highlighting.
This stream is about performance. Demo of the performance of 10x, instant loading of huge projects, instant search etc. The reasons 10x is so fast, C++ usage, writing everything from scratch etc. Getting the most out of the CPU, memory, caches and threading. Explanation of how Workspace Search works. Description of TaskManager. Threading of the parser.
Introduction to the C++ parser. Why it's needed and how it works. The decision not to use an existing compiler front end. How the parser stores lines and tokens. Language grammars. Examples of parsing problems. The parser functional tests in python. How goto-def works, recursion, example walkthrough. Difficulties of an editor parser that a compiler doesn't have. Multi-threaded parsing.
This is the first 10x Live Stream. It has an introduction to 10x and the codebase. Why I started writing 10x. The 10x philosophy. What makes 10x different. Coding style, C++ subset. Overview of all libraries in the 10x codebase. Brief demo of the UI editor. Overview of the UI library. Explanation of the Function class used in UI callbacks. Demo of Workspace Search (FastFind). Telemetry. Demo of goto-definition, find symbol, find references etc.