This is a smaller primarily debugger release, containing some tweaks, fixes, and a few new features.

Debugger Changes

• Added the ability for the debugger to load, use, and evaluate using debug info, even when not actively debugging. The debugger will now keep a process' debug info loaded, even after the process ends. It stores the set of loaded debug info files in the project configuration file, meaning it will also automatically load the same debug info across many runs. Debug info can also be loaded manually (without ever launching a process) with the Load Debug Info command. There is also a new tab, Debug Info, which allows viewing and managing the set of loaded debug info files.
• Improved the debugger's behavior when used as a drag & drop target, to allow for debug info loading as an option (when relevant), and to better handle the case where many files (potentially of different types) are dropped together.
• Improved debug info searching performance and reponsiveness in large projects.
• Fixed some bugs with debug info searching, which were rarely causing searches to fail.
• Fixed some crashes and incorrect results with the new list view. (#666)
• Fixed some cases where RDIs did not contain some basic types from their originating PDBs. (#663)
• Allowed . and -> operators to be used with array types. (#662)
• Fixed the debugger's treatment of quoted command line arguments when building targets. In previous versions, calling raddbg main.exe "foo bar baz" would create a target main.exe with arguments foo bar baz (dropping the quotes). This is now fixed, such that the target's arguments string will also contain the quotes, and pass them to the target when launched.
• Fixed the debugger not correctly responding (through font and UI scale) to DPI changes. (#510)
• Fixed the debugger incorrectly generating conflicting source line info records in PDB -> RDI conversion, which in some scenarios was preventing source line maps from working (leading to breakpoint resolution failing).
• Other small fixes, improvements, and tweaks.

Linker Changes

The linker is unchanged since v0.9.22.

Binary Utility Changes

The binary utility is unchanged since v0.9.23.

This is a small follow-up release to v0.9.22, containing some tweaks, fixes, and a small number of new features.

Debugger Changes

• Further improved PDB -> RDI conversion performance & memory usage.
• Adjusted limits for the amount of PDB -> RDI conversion work that the debugger will kick off, to prevent PDB -> RDI conversion interfering with debuggee performance.
• Reintroduced the list lens, which gathers all nodes in a linked list, and visualizes them as a flat list of pointers (the same as how an array of pointers is visualized).
• Fixed a crash when closing empty Geometry 3D views. (#652, #657)
• Fixed the debugger not visualizing enum types when evaluated through a bitfield type. (#655)
• Fixed the PDB -> RDI conversion not correctly generating location information for function parameters, when the EXE/PDB were built to include support for Edit and Continue (-ZI switch). (#656)

Linker Changes

The linker is unchanged since v0.9.22.

Binary Utility Changes

• Fixed a crash when using the --compress option, when generating RDI files.

This release contains several performance and stability improvements, bugfixes, and some new features.

Debugger Changes

• Further improved PDB -> RDI conversion performance.
• Capped the number of additional threads / processes spawned for PDB -> RDI conversion.
• Prioritize PDB -> RDI conversion based on what is actually found to be necessary by the debugger, rather than converting all PDBs in the order in which they're discovered.
• Added preliminary support for DWARF -> RDI conversion on Windows.
• The debugger now relies on source file checksums to determine whether or not a source file is out-of-date with respect to what was compiled when debug info was produced, rather than just the modification timestamp.
• The debugger now will rely on debug info to detect the language of source code files, if it cannot infer from the source file's extension, or view settings. This will enable features like syntax highlighting and hover evaluation in cases like .inl files being included in C++ projects.
• The debugger now will restore the last focused window when continuing automatically. (#245, #596)
• Watch tables have been simplified in that they no longer have a separate column for evaluation types, since this was usually taking a lot more space than it deserved. The type of evaluations is still displayed in watch table cells, and it can always be evaluated directly via typeof.
• Type evaluations have been simplified in watch tables as well; they no longer have untitled columns for sizes and offsets, this is instead displayed as an extra note by default. Similar behavior to the original behavior can still be obtained using the columns view, if needed.
• The debugger no longer uses complex union types for most registers, and instead just displays the register value plainly.
• The hover evaluation UI has been made larger when needed.
• The debugger now prefers matching global, function, and type identifiers to the most relevant debug info and module in context; this fixes evaluation in some multi-process debugging contexts. (#581)
• Fixed the debugger unnecessarily stripping enum type information when accessed through array operators. (#634)
• The debugger now understands a standalone unsigned keyword as an unsigned int type, to match C rules.
• The debugger now uses the current working directory to form the working directory for targets specified on the command line, to match behavior when running a command from the command line without the debugger.
• Improved call stack computation performance.
• Improved debugger memory usage over long periods of time.
• Fixed string-pointer comparison not working with not-equal (!=) operations.
• Fixed a bug which was causing bad debuggee performance on some threads after some interactions with the debugger controller.
• Fixed incorrect results when adding two register values. (#642)
• Fixed the interpretation of register expressions in visualizers. (#649)
• Fixed "forever loading" states in disassembly views in some cases. (#643)
• Fixed jittering on window resizing. (#636)
• Fixed the bitmap visualizer crashing in some circumstances relating to unsupported bitmap sizes. (#444, #563)
• Fixed a crash when an empty cast() expression would be evaluated. (#625)
• Fixed a crash when an invalid expression would be visualized using the text view. (#647)

Linker Changes

• Changed symbol resolution in libaries to match MSVC behavior.
• Optimized image building step to reduce memory usage.
• Linker memory maps all input files by default to lower memory usage. (/RAD_MEMORY_MAP_FILES)
• If debug info is available, linker uses it to show file and line number for unresolved relocations.
• Improved base relocation build performance for large images, cutting build time by 70%.
• Added stubs for /Brepro, /D2, and /ErrorReport to improve compatability with existing response files
• Implemented section garbage collection (/OPT:REF)
• Fixed bug where thread local variables pointed to incorrect types.
• Changed rules for weak and undefined symbols, now weak symbol is not allowed to replace an undefined symbol.
• Linker no longer creates thunks for imports that don't require them.

Binary Utility Changes

• The binary utility, like the debugger, now can convert DWARF debug info to RDI files. When both DWARF and PDB info is present, it can now convert both, and produce a single final RDI file with all information.
• Textual dumping of RDI files is now done in parallel, massively improving dumping performance.
• PDB -> Breakpad conversion performance has now been parallelized to a greater degree, improving performance.

This release contains several improvements to debugger performance, stability, bugfixes, and some new features.

Debugger Changes

• Majorly improved initial load performance, particularly for very large projects with many DLLs/PDBs.
• Majorly improved global symbol identifier resolution performance in the debugger, which most notably will help the UI's performance when very large projects with many DLLs/PDBs are loaded. (#439)
• Adjusted process control, so that if there is a selected thread, it will attempt to coax the kernel into scheduling that thread first for a short time. This dramatically improves the stepping and breakpoint experience, particularly in heavily multithreaded code, but even on projects with many threads (even if code that is only touched by a single thread is being debugged).
• Added visualization for scopes containing the cursor to the text visualizer (used in viewing source code). This can be turned off via the Cursor Scope Lines setting, which can be found in the palette.
• Expanded the palette to include all source files found within loaded debug information, so even if certain files relevant to a project have not been loaded yet, they can be found easily via the palette, or the lister used for the Switch command.
• Expanded the IPC external driving system to further support command parameters, like targets, threads, and breakpoints. These can be referenced via their label identifier if they have one (e.g. my_breakpoint), their details (e.g. C:/foo/bar/baz.c:123, foo.exe --bar --baz), and their index in the collection of all entities of the same type (e.g. breakpoints[0]). (#445, #571) Below are some usage examples:
  • raddbg --ipc enable_breakpoint main.c:123
  • raddbg --ipc disable_breakpoint C:/foo/bar/baz/main.c:123
  • raddbg --ipc remove_breakpoiint main.c:123
  • raddbg --ipc select_target foo.exe
  • raddbg --ipc select_target foo.exe --bar --baz
• Expanded the IPC external driving system to support returned information from a command. For instance, a command like add_breakpoint will return the internal ID that the debugger uses to identify that breakpoint. This can also be used to precisely refer to the breakpoint in subsequent IPC commands.
• Added the ability to clear the Output log, via the Clear Output command. (#143)
• Adjusted the Bitmap visualizer to hook into the debugger's "rich hover" system. This means that, when pixels are hovered in the Bitmap visualizer, the same memory ranges will highlight in other visualizers.
• Added a symbolof operator in the evaluation system, which will round an address evaluation down to the containing symbol address, if there is one.
• Added the ability to pass a user or project file to the debugger via command line, without using special argument flags; fixed the debugger interpreting that as a target command line. (e.g. raddbg my_project.raddbg is now possible.) (#560)
• Fixed the debugger not applying type views when the associated type was evaluated through a pointer or reference. (#588)
• Fixed incorrect treatment of signed and unsigned integer casting in the evaluation system. (#562)
• Fixed incorrect treatment of sub-64-bit integers in the evaluation system.
• Fixed the debugger unnecessarily stripping enum types (and thus falling back to the underlying basic integer type) when accessing enum types through pointers or references.
• Fixed the debugger unnecessarily prohibiting casts involving enums and bitfield types. (#565)
• Fixed a number of instabilities and crashes related to the new asynchronous call stack computation system. (#535, #554, #550, #530, #556, #568, #574)
• Fixed a number of instabilities with the recently-changed asynchronous process memory reading system, which was rarely causing process memory to not correctly be updated, thus causing watch windows to show stale values. (#502)
• Fixed case changes of certain paths the debugger would make when converting PDB to RDI debug information.
• Fixed the debugger's treatment of debuggee-produced data breakpoint hits (when the debuggee modifies its own registers to set a data breakpoint). The debugger will now correctly stop and report these hits, even though they do not correspond to the debugger's own breakpoint state.
• Fixed the debugger not correctly writing Unicode data to the clipboard.
• Fixed the debugger incorrectly setting read-only data breakpoints. These are not supported in hardware on x64, so in this case, a read-write data breakpoint is set instead.

Linker Changes

The linker is unchanged since 0.9.20. Some big new changes are in flight, so this release just contains the 0.9.20 binary, rather than that from the top of master.

Binary Utility Changes

The radbin binary utility is unchanged since 0.9.20.

This is a small follow-up release to v0.9.19 with fixes, improvements, expanded support, and some new features.

Debugger Changes

• Added the ability for pattern-based type view expressions to use parts of the evaluation's type string (which matched the pattern's wildcards). This is done by adding {<comma-delimited-identifiers>} after a ? used in a type pattern. For example, with the pattern DynamicArray<?{element_type}>, the expression can be array(cast(element_type *)base_pointer, count).
• Added built-in type views for a number of basic Unreal Engine types. These can be enabled or disabled with the Use Default Unreal Engine Type Visualizers setting.
• Added support in RDI for constants defined in debug information, like enum members or global constant values. Also added support for evaluating and autocompleting these constants.
• Added the ability to programmatically construct memory range annotations from target applications with the raddbg_annotate_vaddr_range API in the raddbg_markup.h header library.
• Added automatic memory annotations for globals and procedures found in debug information.
• Improved memory range annotation UI in the memory view.
• Added support for "rich hover" visualization in the memory view and watch tables. When address ranges are hovered in a watch table or memory view, the same addresses will be highlighted in the other; this makes it much easier to correlate between the two views.
• Greatly improved PDB -> RDI conversion speed (fixed regressions caused by non-parallelized inline site conversion).
• Improved the behavior of the find_code_location command to account for multiple windows. Instead of snapping all windows to the destination source code, it will be smarter about which windows are being used for source code and disassembly.
• Fixed a regression with pattern-based type views, which was preventing more complex templated evaluations from correctly having views applied to them. (#517)
• Fixed a bug where the Go To Address command was not snapping the memory view's scroll position to the destination address correctly.
• Fixed various other small bugs in the memory view.
• Fixed some cases where the debugger was not normalizing paths correctly, which caused paths with forward slashes and backwards slashes to be treated differently. (#521)
• Fixed the debugger not storing projects created via Save Project as recent projects, thus preventing them from being automatically reloaded on subsequent runs.

Linker Changes

The linker is unchanged since v0.9.19.

Binary Utility Changes

In previous releases, we packaged our command-line binary analysis utilities like rdi_dump, rdi_from_pdb, and rdi_breakpad_from_pdb along with the debugger and linker binaries. These have been combined into a single program called radbin. radbin can be used to convert PDBs to RDI, to convert PDBs to the textual Breakpad format, and to dump textualizations of all information within an RDI file, so it can be easily inspected in a text editor.

Here are some examples of how one can use radbin (assume that program.exe's debug info is in program.pdb):

• radbin --rdi program.exe: Finds the debug info for program.exe, and converts it to the RDI format, outputting it to program.rdi.
• radbin program.exe --out:program.rdi: Equivalent to above.
• radbin program.pdb --out:program.rdi: Equivalent to above.
• radbin --rdi program.pdb: Equivalent to above.
• radbin --dump program.rdi: Dumps a textualization of all debug information inside of program.rdi to stdout.
• radbin --breakpad program.pdb: Converts debug info in program.pdb to the Breakpad text format, outputting it to program.psym

As usual, all of the binaries we package in each release are standalone. None of them require any of the others to be used.

The debugger executable also contains all of radbin's functionality within itself. It can be used by passing the --bin argument to the debugger. For instance, raddbg --bin --rdi program.exe is equivalent to radbin --rdi program.exe, and raddbg --bin --dump program.rdi is equivalent to radbin --dump program.rdi. That said, because the debugger is built as a graphical program, it will not output its stdout and stderr output to a terminal from which you run it (it can still be piped to an output file, however, like raddbg --bin --dump program.rdi > program.dump).

As we continue making progress on the Linux port, or otherwise expanding our support for the many debugger-and-linker-related file formats, radbin will expand in functionality.

This is a small follow-up release to v0.9.18 to fix the biggest usability issues (largely due to the new asynchronous call stack computation system) and offer a few new improvements. If you're coming from v0.9.15 or earlier, we recommend reading the release notes from v0.9.16 and later, as they contain many important updates.

Debugger Changes

• Added a visualization to show the last hit breakpoint. (#249)
• Added a setting to prefer the operating system's native file picker dialog, over the built-in UI.
• Improved change and memory-read-error visualization in watch tables, to clearly display when certain address ranges either recently changed, or could not be read from a debuggee address space. (#199)
• Improved the debugger's behavior when waiting for new asynchronously computed call stacks or process memory. The debugger UI will now wake up when new results are ready.
• Fixed a bug where the debugger would not correctly generate call stacks if a zero instruction pointer were at the top of the call stack. (#398)
• Fixed a bug where the debugger would hold handles open to DLLs while the UI was not being interacted with, causing debuggees to freeze until the UI was interacted with. (#501)
• Fixed a bug where type view patterns were matching to types that they shouldn't have been. (#500)
• Fixed a bug with the asynchronous call stack building system which was causing local variables or call stacks to not update quickly, or to be incorrect. (#502)
• Fixed a bug which sometimes caused stepping operations to fail when a line's instructions stretched across a page boundary. (#503)
• Fixed a bug with invisible text in single line text views. (#498)
• Fixed some UTF-8 decoding bugs.
• Fixed incorrect local variable location information, when a procedure was the last in a compilation unit.

Linker Changes

The linker is unchanged since v0.9.18.

This is another quick follow-up release containing several fixes and improvements to 0.9.17, which was itself a quick follow-up release to 0.9.16. If you're coming from 0.9.15 or before, the 0.9.16 release notes contain most of the important information about the major changes since 0.9.15. If you have pre-0.9.16 configuration data, please back it up before upgrading to this release, if it contains important data.

The biggest change in this release is that call stack computation is now done asynchronously (in addition to other already asynchronous systems in the debugger, like process memory streaming). Fairly extensive testing and fixing of this system has been done over the past week, but a large number of systems in the debugger depend heavily on call stack correctness, and so if you experience new issues, it may be related to this change. If you do experience such issues, please do not hesitate to report them. Thank you for your patience and help in that case.

Debugger Changes

• Adjusted identifier resolution rules in the evaluation language to prefer visualizer names when used in a call expression. For example, even if you have a variable named bitmap, if you evaluate bitmap(...), it will prefer resolving bitmap to the visualizer. You can still always disambiguate with qualifiers, e.g. local:bitmap or type:bitmap.
• Adjusted the only view to allow arbitrary derivative expressions, rather than only member names. This allows custom expansions to insert rows for arbitrary expressions. These expressions are derivative from the expanded expression, meaning they can refer to the expanded expression via $, or implicitly, its member names.
• Renamed the table view to columns, and the only view to rows, since these more directly reflect the way these views are used in the evaluation visualization pipeline.
• Added an option to all text views to scroll to the bottom if the textual content changes at all. Can be used with the Output tab.
• Improved toggle switches to allow clicking and dragging to toggle many switches in a single operation.
• The debugger now records the last user file which was loaded while it was opened, and reopens that file on startup, if no user is explicitly specified. (#482)
• The debugger now unfocuses query bars (e.g. that opened by Ctrl + F in a source view) if the main view content is clicked by the mouse. The query bar can be refocused also by clicking.
• Moved call stack evaluation to occur asynchronously, so that deeper call stacks (which can be expensive to compute) do not block the UI.
• Stopped the debugger from running the default Windows message handling path for most Alt-based keybindings, which was causing a Windows beep sound to play.
• Fixed a bug where RDI files would sometimes fail to generate, resulting in no debug info being available on some runs.
• Fixed a bug which was preventing backslashes from working in file system querying interfaces correctly.
• Fixed a bug which was preventing some recursive call stacks from fully displaying in the debugger.
• Fixed a bug which prevented Space from being used as a keybinding. Bound Space by default to the Accept command (to which Enter / Return is also defaultly bound).
• Fixed a bug which was preventing conditional breakpoints from correctly being placed, if the condition expression did not evaluate when the debuggees were resumed.
• Fixed the debugger applying too much path processing, which was causing relative paths in debug info to be interpreted incorrectly. The debugger should now work much better with relative paths (e.g. produced via /d1trimfile). In these cases, the debugger may still not be able to fully compute the correct absolute paths, because this information is not stored within debug information. But once the debugger is redirected to the correct file once through the UI, it should work with relative paths correctly.
• If the debugger crashes, the message box which opens and displays the crash call stack now also allows the creation of crash dump files. Please submit these, if possible, with crash reports; it will help us to debug crashes more effectively.
• Fixed a bug which was causing text rendering to fail both when running the debugger on WINE and also on Windows 7.
• Fixed a bug where exception information inlined in source code would overlap the source code text.
• The debugger now correctly correctly interprets relative per-target stdout, stderr, and stdin paths.

Linker Changes

The linker in this release is unchanged since 0.9.17.

This is a quick follow-up release containing several fixes for the last 0.9.16 release. If you're coming from 0.9.15 or before, the 0.9.16 release notes contain much more information about what has changed recently. If you have pre-0.9.16 configuration data, please back it up before upgrading to this release, if it contains important data.

Debugger Changes

• Added a command for clearing all breakpoints. (#468)
• Extended the autocompletion UI to include a helper which shows visualizer arguments and documentation, when that visualizer is being called within an expression.
• Added the Add Function Breakpoint command back. This was initially removed because address breakpoints are now sufficiently powerful to express functions (their locations are just evaluated as expressions), but it was determined that the "Add Function Breakpoint" command, with the associated function lister, was still a useful fast-path. (#480)
• Improved enum value autocompletion, and added filtering of enum values when the . operator is used on an enum type.
• Added support for evaluating symbol names of the form a.b.c, which is a common pattern in many non-C/C++ languages (before, the debugger was treating the .s as regular dot operators in the evaluation language, with no fallback path).
• Fixed a bug where certain Delete-based or Backspace-based controls were over-deleting characters when editing text. (#464)
• Fixed a bug where editing type views would immediately apply to settings evaluations. (#475)
• Fixed a bug which reset custom keybindings every time the debugger launched. (#470)
• Fixed a crash which occurred under some conditions when editing watch expressions. (#471)
• Fixed the debugger not running when being passed the --auto_run flag. (#469)
• Fixed the debugger's treatment of .. in generated source file paths in debug information, which was preventing breakpoints from working in certain cases. (#457)
• Fixed a bug where the debugger would not display negative enum values correctly. (#455)
• Fixed a bug where using a relative project or user path would prevent paths from being correctly relativized on configuration serialization. (#477)
• Added support for arithmetic with bitfield values.
• Added path relativization for breakpoint and watch point source locations. (#477)
• Removed a default keybinding for a now-removed command (reload_active), which was preventing the rebinding of Ctrl + Shift + R correctly.
• Fixed a bug where clicking rows or hitting enter within function listers would not work, when there was no selected thread.
• Fixed a number of other small instabilities and crashes.

Linker Changes

The linker in this release is unchanged since 0.9.16 (and thus 0.9.15).

This release contains a number of major upgrades and changes to the debugger. Huge portions of the debugger have been majorly overhauled, and some portions have been rewritten. These major changes have been made to improve the debugger long-term, and many debugger systems have become more stable, but as with any set of major changes like this, instabilities and new regressions may occur. Thank you for your patience in dealing with those issues. If you happen to find some, please be sure to report them.

IMPORTANT NOTE: This release contains many changes to the configuration file format. Because the debugger is in alpha, and because the relationship between new configuration files and old is not one-to-one, I deemed it low-value to invest a lot of time in preserving all configuration data from earlier versions. Thus, only a small subset of information within old configuration files is preserved when loaded in the 0.9.16 debugger (targets and file path maps, notably). Other information will be lost. Because of this, I recommend backing up your configuration files for the 0.9.15 debugger if they contain useful data to you. That will also be useful if the new version has currently-uncovered instabilities, and you'd like to continue using 0.9.15 until those are resolved.

Below are the list of the most important changes:

Debugger Changes

• Formal integration of views (view rules) into the evaluation language. "View rules", now simply called "views", have been formally integrated into the debugger evaluation language. They now appear similar to function calls, and are expressed directly within an expression. For example, an expression dynamic_array with a view rule slice from prior versions would now be expressed as slice(dynamic_array). Alternatively, views can be expressed with similar syntax to method calls: dynamic_array.slice(). Many views can still be attached to a single expression, like dynamic_array.slice().hex() (equivalent to hex(slice(dynamic_array)). The first argument to a view is the expression to which the view should apply. Some views take additional parameters, like bitmap(base_pointer, width, height). Named parameters, required in some cases (e.g. the fmt/format parameter for bitmap), are expressed using name = value syntax: bitmap(base, width, height, fmt=bgra8).
• Support for generics in type views (auto view rules). "Auto view rules", now simply called "type views", have been upgraded to support type pattern-matching. This makes them usable for generic types in various languages. This pattern-matching is done by using ? characters in a pattern, to specify placeholders for various parts of a type name. For example, the pattern DynamicArray<?> would match DynamicArray<int>, DynamicArray<float>, and so on. ?(?) would match all function types. (#118, #345)
• Usage of the source expression within type views. Type views have been upgraded to support a larger number of possibilities. Instead of mapping to a set of views which are applied to some other expression, type views can remap the expression itself, and apply additional views. These expressions can refer to the originating expression either explicitly using the $ character, or implicitly in some cases. For instance, a type like struct Bitmap {U8 *base; U32 width; U32 height;}; can be used in a type view which maps Bitmap to bitmap(base, width, height). In this case, base, width, and height are recognized as being member names of Bitmap. This is equivalent to bitmap($.base, $.width, $.height).
• Hardware data breakpoints. Breakpoints have been upgraded to support flags for breaking on writing, reading, or execution, as well as an address range size. When used with an address location, this can be used to express hardware data breakpoints, where the CPU will break when it sees particular addresses being written to, read from, or executed, regardless of which code does it. There is a maximum limit of four such breakpoints on a processor. Theoretically, this means a limit of four per thread, but for now, the debugger only supports four global data breakpoints. In the future, we plan to allow organizing these by thread, in which case the total number of data breakpoints we support will increase.
• A new table view has been added, which allows one to define custom rules for how rows of a watch expansion are formed. The first argument a table is the expression which should be evaluated (like other views), and the remaining arguments are used to express a number of expressions which should be used to generated cells for each row in the expansion. For instance, table(my_int_array, $, $*4, $*8) would expand my_int_array, but instead of the default row structure (which displays an expression string, a value string, and a type string), three cells would be generated per row: one with the value of each element, one with that value multiplied by 4, and one multiplied by 8.
• A new sequence view has been added. This is a simple view which simply takes a single integer scalar argument n, and returns a sequence of integers, from 0, 1, 2, all the way to n. This sequence can be expanded. This can compose with the table view, to easily generate n rows, and use each integer as a value in each cell expression. As an example, table(sequence(1000), array1[$], array2[$]) would display elements of array1 and array2 in each row, side-by-side.
• The everything palette. The F1 command palette has been replaced by a substantially more powerful "everything palette" (referred to in the UI simply as "palette"), opened with the Open Palette command. This palette lists commands and allows the editing of bindings, just like the old command palette (although it now also supports searching for command bindings themselves, in addition to the original searching support for command names and descriptions). However, this palette now also lists targets, breakpoints, recent files, recent projects, settings (including tab settings, window settings, user settings, project settings), attached processes, threads, modules, functions, types, and global variables. This can be used to quickly search for a large set of possible things, and either jump to them or edit them. The old Run Command command still exists, and still presents a command palette, which is simply a special-case of the generalized palette. But this command is no longer bound to F1 by default.
• Upgraded per-tab settings. The tab right-click menu has been upgraded to show all tab-related settings, including ones specially-defined for specific visualizers (like the width and height parameters to the bitmap visualizer). The debugger UI now also supports per-tab font sizes. If a tab has no per-tab font size set, then it inherits the window's font size. Each tab's root expression is now also editable in this interface. The tab right-click menu's options also show up in the palette when the corresponding tab is focused. They can also be manually opened with the Tab Settings command.
• UI for setting fonts. The fonts which the debugger uses can now be set through settings UI (including the palette), rather than just through the configuration files.
• Support for searching system font folders for fonts. The debugger now accepts system font file names in addition to full font file paths to specify font settings.
• Per-Watch expressions and labels. Expressions inserted into a Watch tab are now stored per-tab. This makes many Watch tabs more useful, since different tabs can have a different set of expressions. Watch tabs can now also be labeled, so you can visually distinguish many Watch tabs more easily.
• Evaluation drag/drop. Evaluations in a watch tree can be dragged and dropped. This can be used to create new top-level rows in a Watch tab, or to drag evaluations between Watch tabs, or to drag evaluations to source or disassembly views and pin the evaluation to some location there. (#137, #388)
• Settings expressions. Debugger settings have been upgraded to be stored as expressions, rather than being locked to a specific value. These expressions are evaluated, like any other expression, and their evaluated value is used when the setting value is actually needed.
• Upgrades to the slice view. The slice view has been streamlined and simplified. When an expression with a slice view is expanded, it will simply expand to the slice's contents, which matches the behavior with static arrays. The slice view now also supports first, one_past_last pointer pairs, as well as base_pointer, length pairs.
• Boolean evaluation toggle-switches. The debugger now displays toggle switches as an additional visualization and editor for all boolean evaluations.
• A new range1 view has been added, which expresses bounds for some scalar value. When this view is used in an evaluation, the debugger will visualize the evaluation value with a slider, which can be used to edit the value as well.
• Merging of Watch UI with hover evaluation. The hover evaluation feature has been majorly upgraded to support all features normally available in Watch tabs. (#342)
• Added transient tabs, which are colored differently than normal tabs. These tabs are automatically opened by the debugger when snapping to source code which is not already opened. They are automatically replaced and recycled when the debugger needs to snap to new locations. This will greatly reduce the number of unused source code tabs accumulated throughout a debugging session. These tabs can still be promoted to permanent tabs, in which case they'll stay around until manually closed.
• The Scheduler tab has been removed, in favor of three separate tabs, which present various versions of the same information: Threads, `...

This release contains many smaller fixes and features for both the debugger and linker. A number of major upgrades are coming to the debugger in 0.9.16, but they'll take a bit more time; this release just contains many stability and usability improvements since 0.9.14.

Debugger Changes

• Changed string visualization to respect array sizes in an evaluation's type, making the slice view rule more useful for strings.
• Adjusted value committing rules in watch windows, to immediately commit values when editing debugger configuration (while still retaining the ability to escape and retain the old value). This fixes user experience issues where edits to things like breakpoints or targets were not being immediately recognized by the debugger (as they were not explicitly committed by the user).
• Introduced better support for an edge case in PDB generation, where a variable which was used as a return value would not have type information explicitly attached in the debug information.
• Fixed a bug which was causing the memory view to be truncated to 16 KB with active processes. (#375)
• Fixed a case where files were spuriously being displayed as out-of-date.
• Fixed artifacts relating to custom window border during resizes.
• Fixed window fullscreen and placement bugs relating to the custom window border.
• Fixed bug where panels would disappear if the window was minimized or sufficiently shrunk. (#385, #401)
• Fixed a bug in inline line information parsing, which caused breakpoint traps to be placed at an invalid instruction addresses when placed in inline sites, generally in release builds.
• Fixed some cases where spurious exceptions were being generated, due to "spoofs" (bogus return addresses the debugger writes into a call stack, in order to step over potentially-recursive calls).
• Fixed a bug where the debugger would freeze when editing certain expressions. (#362)
• Fixed a crash with assembly-style register offset dereference evaluations (e.g. [rdx+0x40]). (#378)
• Fixed a hang when entering long strings for target or breakpoint information. (#387)
• Fixed a crash in the debug info fuzzy searching system. (#363)
• Fixed a crash or invalid state case when a debug info tab (e.g. Types, Procedures) was visible upon starting a debugging session. (#420)

Linker Changes

• Fixed a crash when linking against same DLL statically and dynamically.
• Fixed a bug in global symbol table sorter which prevented debugger from looking up certain symbols.
• Reduced overall memory usage.
• Added support for /FUNCTIONPADMIN.
• Fixed a crash when emitting base relocations for 32-bit pointers.
• Added /RAD_SHARED_THREAD_POOL which tells linker to use a shared semaphore to utilize better system resources when spawning many linker instances at the same time.
• Added /RAD_WRITE_TEMP_FILES to prevent leaving corrupted files on disk when linker is terminated mid write, files are renamed after all writes successfully finish.