Skip to content
| Marketplace
Sign in
Visual Studio Code>Themes>RosinNew to Visual Studio Code? Get it now.
Rosin

Rosin

Debjoy Howlader

|
5 installs
| (0) | Free
Calm, low-glare dark themes, with consistent colour meaning across languages, build tools and logs.
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

Rosin icon

Rosin

Calm, low-glare dark themes for VS Code, where each colour keeps one meaning across languages.

Install from the VS Marketplace Download the .vsix View on GitHub

Rosin flavours

Flavours

  • Rosin · Sea Salt
  • Rosin · Black Cherry
  • Rosin · Matcha
  • Rosin · Espresso
  • Rosin · Licorice
  • Rosin · OLED

Highlights

  • One meaning per colour. A function is the function colour in C, Rust, Python, Makefiles and linker scripts alike. Where a grammar or language server can't tell two roles apart, the exception is listed under Language support.
  • Built for semantic highlighting. Tuned for C/C++ IntelliSense and clangd, rust-analyzer and Pylance. With a language server running, globals, statics, parameters, methods and library calls each get their own colour.
  • Toolchains as well as languages. Makefiles, CMake, shell, PowerShell, TOML, INI, YAML, Dockerfiles, diffs and git get the same care. Assembly, linker-script and devicetree grammars get it too, when an extension provides them.
  • Readable logs. In .log files, errors, warnings, info and debug lines each get their own colour. ESP-IDF style (E (512) tag:) and Zephyr style (<err>) levels are recognised, along with panic and fault messages.
  • Contrast checked. Body text is above WCAG AA in every flavour, while comments and punctuation are deliberately quieter.

What each colour means

Every flavour uses the same roles. The Colours tables give each flavour's hex values.

Meaning What gets it Examples
Text / variable Local variables, and anything the grammar or server leaves unclassified count buf
Keyword Control flow, declarations, keywords that introduce a type, build-language keywords if return struct fn ifeq
Qualifier Storage and type qualifiers, CMake keyword arguments const static extern volatile PRIVATE
Function Functions you define or call; labels (italic) ¹ led_set()
Method Methods and member functions ¹ .write() __init__
Library function Standard-library and built-in functions ¹ print echo $(wildcard …) printf
Macro (bold) Preprocessor macros and macro calls LED_PIN BIT(n) __FILE__
Preprocessor / attribute Directives, attributes, decorators #include #[derive] @dataclass
Namespace / module Namespaces, modules and the :: between them std core::ptr
Primitive type Built-in and standard-library types int u32 str String ¹
User type Types you define led_t Led
Parameter (italic) Parameters, self, this, macro parameters len self $x
Member / key / flag Fields, config keys, command-line flags .pin name: --baud
Global / config variable Global variables ¹, build and environment variables, linker symbols g_ticks $(CC) ${BOARD} _etext
Static variable File- and function-scope statics ¹ s_state
Number / constant / enum Numbers, booleans, null values, enum members 42 true None Some
Unit Number base prefixes, suffixes and exponents; literal suffixes 0x UL e-3 _ms
String Strings and unquoted config values "hello"
Escape Escape sequences and entities \n &amp;
Hazard Pointers, bit operations, format specifiers *p -> << %d
Operator Assignment, arithmetic and comparison operators = + ==
Punctuation Separators, brackets, string quotes ; , {}
Comment (italic) Comments // note
Doc comment (italic) Documentation comments /// returns
Error / warning Log levels, unresolved names ERROR WARN
Diff added / removed Diff lines + / -

¹ In some languages only a language server can tell these apart from an ordinary function, variable or type. The sections under Language support say which, and what you see without one.

Colours

Rosin · Sea Salt

Meaning Example Hex
#13171F Editor background #13171F
#0D1117 Panels / sidebar #0D1117
#333A5F Selection #333A5F
#AEA7ED UI accent #AEA7ED
#C6CDD4 Text / variable count buf #C6CDD4
#E59B5B Keyword / control flow if return struct fn #E59B5B
#9CADCB Qualifier const static extern #9CADCB
#B5A4FF Function led_set() #B5A4FF
#C0B2FF Method .write() #C0B2FF
#8D96BE Library / builtin function print echo printf #8D96BE
#E497CE Macro (bold) LED_PIN BIT(n) #E497CE
#AB81AD Preprocessor / attribute #include #[derive] #AB81AD
#6F9895 Namespace / module std core::ptr #6F9895
#5EA0CD Primitive type int u32 str #5EA0CD
#75CCC4 User type led_t Led #75CCC4
#C2B7DB Parameter / self (italic) len self #C2B7DB
#7DABB0 Member / key / CLI flag .pin name: --baud #7DABB0
#DEAF97 Global / config variable g_ticks $(CC) #DEAF97
#ADC6A8 Static variable s_state #ADC6A8
#D5C984 Number / constant / enum 42 true None #D5C984
#AEA581 Unit: number prefix / suffix 0x UL _ms #AEA581
#75C290 String "hello" #75C290
#CB8871 Escape \n &amp; #CB8871
#E2726B Hazard: pointer / bits / format * -> << %d #E2726B
#8A939E Operator = + == #8A939E
#6A727D Punctuation ; , {} #6A727D
#7A8696 Comment (italic) // note #7A8696
#AE9B7F Doc comment (italic) /// returns #AE9B7F
#E97074 Error / log error ERROR #E97074
#E59B5B Warning / log warning WARN #E59B5B
#75C290 #E97074 Diff added / removed + / - #75C290 #E97074

Rosin · Black Cherry

Meaning Example Hex
#1E131A Editor background #1E131A
#160E13 Panels / sidebar #160E13
#462D4B Selection #462D4B
#C28DD7 UI accent #C28DD7
#D4C8CF Text / variable count buf #D4C8CF
#DB7489 Keyword / control flow if return struct fn #DB7489
#A1ABCC Qualifier const static extern #A1ABCC
#DAB663 Function led_set() #DAB663
#DCC27B Method .write() #DCC27B
#AA966E Library / builtin function print echo printf #AA966E
#D297E5 Macro (bold) LED_PIN BIT(n) #D297E5
#A184BB Preprocessor / attribute #include #[derive] #A184BB
#6F9896 Namespace / module std core::ptr #6F9896
#649FCB Primitive type int u32 str #649FCB
#74CCCB User type led_t Led #74CCCB
#C1B7DC Parameter / self (italic) len self #C1B7DC
#7DABB0 Member / key / CLI flag .pin name: --baud #7DABB0
#DEB49B Global / config variable g_ticks $(CC) #DEB49B
#ADC6A8 Static variable s_state #ADC6A8
#ECB0C6 Number / constant / enum 42 true None #ECB0C6
#B693A0 Unit: number prefix / suffix 0x UL _ms #B693A0
#79C49C String "hello" #79C49C
#C89164 Escape \n &amp; #C89164
#E3814A Hazard: pointer / bits / format * -> << %d #E3814A
#9D8C97 Operator = + == #9D8C97
#7C6C76 Punctuation ; , {} #7C6C76
#957D8C Comment (italic) // note #957D8C
#B39982 Doc comment (italic) /// returns #B39982
#E97074 Error / log error ERROR #E97074
#DAB663 Warning / log warning WARN #DAB663
#79C49C #E97074 Diff added / removed + / - #79C49C #E97074

Rosin · Matcha

Meaning Example Hex
#141A17 Editor background #141A17
#0E1210 Panels / sidebar #0E1210
#374831 Selection #374831
#9CC97A UI accent #9CC97A
#CBD4CB Text / variable count buf #CBD4CB
#E8A0AA Keyword / control flow if return struct fn #E8A0AA
#A2B8AE Qualifier const static extern #A2B8AE
#A8D17E Function led_set() #A8D17E
#B8DA92 Method .write() #B8DA92
#93A88C Library / builtin function print echo printf #93A88C
#DFA2D6 Macro (bold) LED_PIN BIT(n) #DFA2D6
#B49AC0 Preprocessor / attribute #include #[derive] #B49AC0
#73A08E Namespace / module std core::ptr #73A08E
#7FB8D6 Primitive type int u32 str #7FB8D6
#7CCBB4 User type led_t Led #7CCBB4
#C8BFDA Parameter / self (italic) len self #C8BFDA
#A3B9C8 Member / key / CLI flag .pin name: --baud #A3B9C8
#E2C39E Global / config variable g_ticks $(CC) #E2C39E
#B9D0A8 Static variable s_state #B9D0A8
#B9B8EE Number / constant / enum 42 true None #B9B8EE
#B9A08A Unit: number prefix / suffix 0x UL _ms #B9A08A
#D8C38A String "hello" #D8C38A
#D9A274 Escape \n &amp; #D9A274
#E57A6E Hazard: pointer / bits / format * -> << %d #E57A6E
#8E9C92 Operator = + == #8E9C92
#6C796F Punctuation ; , {} #6C796F
#7E8D82 Comment (italic) // note #7E8D82
#AEA382 Doc comment (italic) /// returns #AEA382
#EC7A7A Error / log error ERROR #EC7A7A
#E0B070 Warning / log warning WARN #E0B070
#8CCB86 #EC7A7A Diff added / removed + / - #8CCB86 #EC7A7A

Rosin · Espresso

Meaning Example Hex
#1B1714 Editor background #1B1714
#12100E Panels / sidebar #12100E
#4C3B27 Selection #4C3B27
#D9A15E UI accent #D9A15E
#DDD2C6 Text / variable count buf #DDD2C6
#DE8C6C Keyword / control flow if return struct fn #DE8C6C
#B5ACBA Qualifier const static extern #B5ACBA
#E8B565 Function led_set() #E8B565
#EEC47F Method .write() #EEC47F
#B59D7A Library / builtin function print echo printf #B59D7A
#DA9DC6 Macro (bold) LED_PIN BIT(n) #DA9DC6
#BB91AC Preprocessor / attribute #include #[derive] #BB91AC
#8AA59C Namespace / module std core::ptr #8AA59C
#8DB2CD Primitive type int u32 str #8DB2CD
#86C2B2 User type led_t Led #86C2B2
#CEC0D8 Parameter / self (italic) len self #CEC0D8
#AABAC5 Member / key / CLI flag .pin name: --baud #AABAC5
#E7C4A1 Global / config variable g_ticks $(CC) #E7C4A1
#BDC9A5 Static variable s_state #BDC9A5
#C7B5E4 Number / constant / enum 42 true None #C7B5E4
#BEA18A Unit: number prefix / suffix 0x UL _ms #BEA18A
#A9C48E String "hello" #A9C48E
#D8A26C Escape \n &amp; #D8A26C
#E3785E Hazard: pointer / bits / format * -> << %d #E3785E
#A2968C Operator = + == #A2968C
#7C7066 Punctuation ; , {} #7C7066
#918376 Comment (italic) // note #918376
#B7A487 Doc comment (italic) /// returns #B7A487
#EA7070 Error / log error ERROR #EA7070
#E3C46F Warning / log warning WARN #E3C46F
#9AC68C #EA7070 Diff added / removed + / - #9AC68C #EA7070

Rosin · Licorice

Meaning Example Hex
#121314 Editor background #121314
#0C0D0E Panels / sidebar #0C0D0E
#2A3540 Selection #2A3540
#94B9DA UI accent #94B9DA
#CACCCE Text / variable count buf #CACCCE
#8E9296 Keyword / control flow if return struct fn #8E9296
#868A8E Qualifier const static extern #868A8E
#94B9DA Function led_set() #94B9DA
#A7C6E2 Method .write() #A7C6E2
#8FA2B5 Library / builtin function print echo printf #8FA2B5
#E4E6E8 Macro (bold) LED_PIN BIT(n) #E4E6E8
#808488 Preprocessor / attribute #include #[derive] #808488
#7F8387 Namespace / module std core::ptr #7F8387
#A6AAAE Primitive type int u32 str #A6AAAE
#D6D8DA User type led_t Led #D6D8DA
#B9BCBF Parameter / self (italic) len self #B9BCBF
#B3B6B9 Member / key / CLI flag .pin name: --baud #B3B6B9
#E8E9EA Global / config variable g_ticks $(CC) #E8E9EA
#C0C3C6 Static variable s_state #C0C3C6
#DDDFE1 Number / constant / enum 42 true None #DDDFE1
#A3A6A9 Unit: number prefix / suffix 0x UL _ms #A3A6A9
#A7BDA2 String "hello" #A7BDA2
#C3C7CA Escape \n &amp; #C3C7CA
#D9827A Hazard: pointer / bits / format * -> << %d #D9827A
#8A8E92 Operator = + == #8A8E92
#66696D Punctuation ; , {} #66696D
#7A7E82 Comment (italic) // note #7A7E82
#8F9397 Doc comment (italic) /// returns #8F9397
#D9827A Error / log error ERROR #D9827A
#C9A66B Warning / log warning WARN #C9A66B
#9CB896 #D9827A Diff added / removed + / - #9CB896 #D9827A

Rosin · OLED

Meaning Example Hex
#000000 Editor background #000000
#000000 Panels / sidebar #000000
#2A2840 Selection #2A2840
#AEA7ED UI accent #AEA7ED
#C6CDD4 Text / variable count buf #C6CDD4
#E59B5B Keyword / control flow if return struct fn #E59B5B
#9CADCB Qualifier const static extern #9CADCB
#B5A4FF Function led_set() #B5A4FF
#C0B2FF Method .write() #C0B2FF
#8D96BE Library / builtin function print echo printf #8D96BE
#E497CE Macro (bold) LED_PIN BIT(n) #E497CE
#AB81AD Preprocessor / attribute #include #[derive] #AB81AD
#6F9895 Namespace / module std core::ptr #6F9895
#5EA0CD Primitive type int u32 str #5EA0CD
#75CCC4 User type led_t Led #75CCC4
#C2B7DB Parameter / self (italic) len self #C2B7DB
#7DABB0 Member / key / CLI flag .pin name: --baud #7DABB0
#DEAF97 Global / config variable g_ticks $(CC) #DEAF97
#ADC6A8 Static variable s_state #ADC6A8
#D5C984 Number / constant / enum 42 true None #D5C984
#AEA581 Unit: number prefix / suffix 0x UL _ms #AEA581
#75C290 String "hello" #75C290
#CB8871 Escape \n &amp; #CB8871
#E2726B Hazard: pointer / bits / format * -> << %d #E2726B
#8A939E Operator = + == #8A939E
#6A727D Punctuation ; , {} #6A727D
#7A8696 Comment (italic) // note #7A8696
#AE9B7F Doc comment (italic) /// returns #AE9B7F
#E97074 Error / log error ERROR #E97074
#E59B5B Warning / log warning WARN #E59B5B
#75C290 #E97074 Diff added / removed + / - #75C290 #E97074

Language support

Each language below was checked token by token, with and without its language server. A few constructs can't be coloured by their meaning, because the grammar or the server gives them exactly the same label as something else. Those exceptions are listed per language and per setup: pick the heading that matches the language server you have installed (or none), and that list is complete for it.

C and C++

  • Grammar: built in.
  • Recommended: C/C++ (ms-vscode.cpptools) 1.35.6; or clangd (llvm-vs-code-extensions.vscode-clangd) 0.6.0 with clangd 23.1.0.
  • Checked tokens shown as designed: 298 of 368 without a language server; 312 of 368 with cpptools; 318 of 368 with clangd.
  • Use one server or the other. clangd tells more roles apart: library functions, deduced types, concepts and file-scope statics. The two servers label a few tokens differently, so those tokens change colour when you switch. The servers were tested with "C_Cpp.enhancedColorization": "enabled" (the default).

Pick the line that matches what you have installed. Each list is complete for that setup.

Neither cpptools nor clangd: 70 exceptions
Token Should be Shown as Why
else_branch comment text the grammar scopes it exactly like u8_custom (user type).
fail function text asm goto label operand gets only meta.function-call.c.
done, out, retry function text only a language server can tell.
V function text the grammar scopes it exactly like Led2 (user type).
Led2 function text the grammar scopes it exactly like the user type Led2 elsewhere in the file.
callback global / config variable function only a language server can tell.
g_ticks, callback, REG_CTRL, fp2 global / config variable text only a language server can tell.
*, &, ~, ^, \| hazard operator the grammar scopes it exactly like + (operator).
* hazard operator unary * (deref) and binary * (multiply) share keyword.operator.arithmetic.cpp.
\|= hazard two colours the C++ grammar scopes \| of \|= as a bitwise operator and = as assignment, so the compound operator is half hazard, half quiet (clangd colours it whole).
static_assert, typeof keyword function the grammar scopes it exactly like BIT (macro).
_Static_assert keyword function the grammar scopes it exactly like add (function).
auto keyword primitive type auto has the same scope as void, int (storage.type.built-in.primitive.cpp). clangd fixes it with type.deduced.
alignas keyword punctuation alignas is scoped as the opening punctuation of an attribute, same as [[.
printf, memcpy library function function the grammar scopes it exactly like BIT (macro).
BIT macro function the grammar scopes it exactly like printf (library function).
NULL macro number / constant NULL and true share constant.language.c.
cb member / key function only a language server can tell.
v member / key function the grammar scopes it exactly like Led2 (function).
v member / key text int v = 0; in a class body has the same scope as an assignment to a local variable.
pin, reg, flag member / key text the grammar scopes it exactly like MODE_OFF (number / constant).
on, get method function only a language server can tell.
hal namespace text hal in hal::init() gets entity.name.scope-resolution.cpp, the scope the grammar also gives enum types, class names and destructor owners.
k_max number / constant text only a language server can tell.
On number / constant text the grammar puts the name itself in the scope (variable.other.unknown.<name>), so no rule can match the role.
MODE_ON number / constant text the grammar scopes it exactly like ... (punctuation).
MODE_OFF number / constant text the grammar scopes it exactly like pin (member / key).
fp parameter function only a language server can tell.
n parameter preprocessor / attribute the grammar scopes it exactly like ## (preprocessor / attribute).
a parameter text only a language server can tell.
x parameter text the grammar puts the name itself in the scope (variable.other.unknown.<name>), so no rule can match the role.
__attribute__ preprocessor / attribute function the grammar scopes it exactly like add (function).
... punctuation text ... in a parameter list gets only meta.function.definition.parameters.
... punctuation text the grammar scopes it exactly like MODE_ON (number / constant).
_Noreturn qualifier text the grammar scopes it exactly like pin (member / key).
s_count static variable text only a language server can tell.
count static variable text the grammar puts the name itself in the scope (variable.other.unknown.<name>), so no rule can match the role.
u8 string text the grammar scopes it exactly like u8_custom (user type).
twice text function only a language server can tell.
led2_t user type primitive type any name ending in _t gets support.type.posix-reserved.cpp, so a user typedef led2_t looks like pid_t. Servers fix it.
Led2 user type text Led2::Led2() is scoped as a qualified call (entity.name.scope-resolution.function.call.cpp), the same as ns::f().
Base user type text base class name in struct D : Base gets only meta.head.struct.cpp.
Mode user type text entity.name.scope-resolution.cpp covers enum types, namespaces and destructor owners alike.
Small user type text the grammar puts the name itself in the scope (variable.other.unknown.<name>), so no rule can match the role (clangd fixes it with concept).
Led2, Box2 user type text the grammar scopes it exactly like V (function).
u8_custom, led, mode user type text the grammar scopes it exactly like s_count (static variable).
With cpptools: 55 exceptions
Token Should be Shown as Why
else_branch comment text the grammar scopes it exactly like u8 (string).
operator function keyword the server labels it exactly like new (keyword).
operator==, operator+ function library function cpptools gives operator-overload declarations and overloaded operator uses the same type with no modifiers; uses keep the library-function colour.
f function method cpptools calls V::f() a static method; clangd a function.
Led, V, Led2 function method the server labels it exactly like on (method).
operator"", _ms function unit the server labels it exactly like 250 (number / constant).
V, Led2 function user type the server labels it exactly like T (primitive type).
*, &, ~, ^, \| hazard operator the grammar scopes it exactly like + (operator).
* hazard operator unary * (deref) and binary * (multiply) share keyword.operator.arithmetic.cpp.
\|= hazard two colours the C++ grammar scopes \| of \|= as a bitwise operator and = as assignment, so the compound operator is half hazard, half quiet (clangd colours it whole).
static_assert, typeof keyword function cpptools and clangd emit no semantic token for static_assert / typeof; the TextMate fallback is the function-call scope.
_Static_assert keyword function the grammar scopes it exactly like __attribute__ (preprocessor / attribute).
auto keyword primitive type auto has the same scope as void, int (storage.type.built-in.primitive.cpp). clangd fixes it with type.deduced.
alignas keyword punctuation alignas is scoped as the opening punctuation of an attribute, same as [[.
printf, memcpy library function function the server labels it exactly like add (function).
k_max number / constant global / config variable the server labels it exactly like s_count (static variable).
true number / constant macro the server labels it exactly like LED_PIN (macro).
250 number / constant unit the server labels it exactly like operator"" (function).
n parameter member / key the server labels it exactly like pin_ (member / key).
n parameter preprocessor / attribute the grammar scopes it exactly like ## (preprocessor / attribute).
x parameter text the grammar puts the name itself in the scope (variable.other.unknown.<name>), so no rule can match the role.
x parameter text the server labels it exactly like i (text).
__attribute__ preprocessor / attribute function the grammar scopes it exactly like _Static_assert (keyword).
bool primitive type macro the server labels it exactly like LED_PIN (macro).
T primitive type user type the server labels it exactly like Led (user type).
pid_t primitive type user type the server labels it exactly like T (primitive type).
uint8_t, size_t, pthread_t, int8_t, uintptr_t, ssize_t primitive type user type the server labels it exactly like u8_custom (user type).
... punctuation text GNU case range ... gets only meta.conditional.case.c.
... punctuation text ... in a parameter list gets only meta.function.definition.parameters.
_Noreturn qualifier text _Noreturn gets only meta.block.c.
s_count static variable global / config variable the server labels it exactly like g_ticks (global / config variable).
u8 string text the grammar scopes it exactly like else_branch (comment).
twice text function cpptools calls a lambda through a variable a function; clangd calls it a variable.
With clangd: 50 exceptions
Token Should be Shown as Why
else_branch comment text the grammar scopes it exactly like u8 (string).
fail function text asm goto label operand gets only meta.function-call.c.
operator==, operator+ function two colours clangd marks only the word operator as the function; the operator symbols keep the grammar colour.
V, Led2 function user type the server labels it exactly like Led (user type).
* hazard operator pointer declarator * shares keyword.operator.c with multiply; clangd sends no token for it.
&, *, \|=, ~, ^, <<=, &=, >>=, \| hazard operator the server labels it exactly like + (operator).
&, \|, ^, ~, <<, \|=, * hazard operator the server labels it exactly like new (keyword).
static_assert, typeof keyword function cpptools and clangd emit no semantic token for static_assert / typeof; the TextMate fallback is the function-call scope.
_Static_assert keyword function the grammar scopes it exactly like __attribute__ (preprocessor / attribute).
new, delete, ?, && keyword operator the server labels it exactly like & (hazard).
!, ? keyword operator the server labels it exactly like + (operator).
auto keyword primitive type clangd emits no token for auto when the deduced type is a lambda (auto twice = [&](https://github.com/debjoy-howlader/rosin-theme/blob/HEAD/int x) {...}), so the grammar's primitive-type scope shows; for other deduced types clangd's type.deduced fixes it.
alignas keyword punctuation alignas is scoped as the opening punctuation of an attribute, same as [[.
true number / constant macro the server labels it exactly like DEBUG (macro).
n parameter preprocessor / attribute the grammar scopes it exactly like ## (preprocessor / attribute).
x parameter text the grammar puts the name itself in the scope (variable.other.unknown.<name>), so no rule can match the role.
n parameter text the server labels it exactly like i (text).
x parameter text the server labels it exactly like twice (text).
__attribute__ preprocessor / attribute function the grammar scopes it exactly like _Static_assert (keyword).
bool primitive type macro the server labels it exactly like DEBUG (macro).
... punctuation text GNU case range ... gets only meta.conditional.case.c.
... punctuation text ... in a parameter list gets only meta.function.definition.parameters.
_Noreturn qualifier text _Noreturn gets only meta.block.c.
u8 string text the grammar scopes it exactly like else_branch (comment).

Rust

  • Grammar: built in.
  • Recommended: rust-analyzer (rust-lang.rust-analyzer) 0.3.3121.
  • Checked tokens shown as designed: 93 of 118 without a language server; 102 of 118 with rust-analyzer.
  • rust-analyzer could not resolve standard-library macros such as println! and write! on Rust 1.93.1. Rosin shows unresolved names in the error style (red, bold, underlined), so these calls look like errors. This is a toolchain problem, not a theme rule; it goes away when rust-analyzer can resolve the standard library.

Pick the line that matches what you have installed. Each list is complete for that setup.

Without rust-analyzer: 25 exceptions
Token Should be Shown as Why
Corpus doc comment comment //! inner doc comments get comment.line.double-slash.rust, same as // (grammar source).
'outer function primitive type the grammar scopes it exactly like 'a (primitive type).
unsafe hazard keyword the grammar scopes it exactly like impl (keyword).
^= hazard operator rust-analyzer marks every compound assignment (+=, ^=) operator.mutable; without it ^= shares keyword.operator.assignment.rust with =.
new, len library function function only a language server can tell.
id member / key text Rust field access is unscoped (rust-analyzer fixes it).
id member / key text the grammar scopes it exactly like name (text).
toggle method function only a language server can tell.
fmt namespace text module names in use paths get only meta.use.rust (rust-analyzer fixes it).
Low number / constant user type the grammar scopes it exactly like T (primitive type).
\| operator keyword closure \| shares keyword.operator.logical.rust with ^ \|\| && << >> ! (grammar source).
addr parameter text parameters, fields and locals share variable.other.rust without rust-analyzer.
x parameter text the grammar scopes it exactly like id (member / key).
Debug preprocessor / attribute user type entity.name.type.rust covers derive items, user types, std types, generics.
Result, String primitive type user type only a language server can tell.
T primitive type user type the grammar scopes it exactly like Low (number / constant).
TICKS static variable number / constant the grammar scopes it exactly like CTRL (number / constant).
twice text function only a language server can tell.
With rust-analyzer: 16 exceptions
Token Should be Shown as Why
* hazard keyword the server labels it exactly like use (keyword).
^= hazard operator rust-analyzer marks every compound assignment (+=, ^=) operator.mutable; without it ^= shares keyword.operator.assignment.rust with =.
& hazard operator the server labels it exactly like :: (namespace).
{}, {name} hazard string the server labels it exactly like pin (string).
write, println macro error println! / write! unresolved; Rosin shows unresolvedReference as error.
:: namespace operator the server labels it exactly like & (hazard).
\| operator keyword closure \| shares keyword.operator.logical.rust with ^ \|\| && << >> ! (grammar source).
pub, mut qualifier keyword the server labels it exactly like use (keyword).
u8, e, - unit number / constant the server labels it exactly like 7 (number / constant).

Python

  • Grammar: built in.
  • Recommended: Pylance (ms-python.vscode-pylance) 2026.4.1, with Python (ms-python.python) 2026.10.0.
  • Checked tokens shown as designed: 83 of 93 without a language server; 92 of 93 with Pylance.
  • Pylance brings its own grammar as well as semantic tokens, so "without a language server" here means without Pylance.

Pick the line that matches what you have installed. Each list is complete for that setup.

Without Pylance: 10 exceptions
Token Should be Shown as Why
(?P< hazard two colours the regex grammar splits a named group opener (?P< into punctuation and a group-name scope.
dataclass library function text the grammar scopes it exactly like os (namespace).
number member / key text attribute access without Pylance gets only meta.attribute.python.
number member / key text only a language server can tell.
write method function library method calls and plain calls share meta.function-call.generic.python without Pylance.
make method function only a language server can tell.
os, dataclasses namespace text the grammar scopes it exactly like dataclass (library function).
f text function only a language server can tell.
With Pylance: 1 exception
Token Should be Shown as Why
(?P< hazard two colours the regex grammar splits a named group opener (?P< into punctuation and a group-name scope.

Shell (bash)

  • Grammar: built in.
  • Checked tokens shown as designed: 87 of 98 as tested.
  • Tested with Bash IDE (mads-hartmann.bash-ide-vscode) 1.43.2 installed. It provides no semantic tokens, so colours are the same with or without it.
11 exceptions
Token Should be Shown as Why
\x41, \033 escape string escapes inside bash $'...' strings are not tokenized.
@ hazard operator the grammar scopes it exactly like :- (operator).
@( hazard two colours the bash grammar does not recognise extglob @(...); @ is plain text and ( punctuation.
\|\| keyword operator the grammar scopes it exactly like \| (operator).
-f member / key keyword -f test flags share keyword.operator.logical.shell with && == != (grammar source).
~ operator text ~ in shell is unscoped.
&> operator two colours the bash grammar splits &> into a background & and a redirect >.
$[ punctuation text $[ ] arithmetic is unscoped.

Makefiles

  • Grammar: built in.
  • Checked tokens shown as designed: 24 of 25 as tested.
  • Tested with Makefile Tools (ms-vscode.makefile-tools) 0.12.17 installed; it does not change colours.
1 exception
Token Should be Shown as Why
-Wall member / key text Make recipe flags (-Wall) are unscoped.

CMake

  • Grammar: CMake Tools (ms-vscode.cmake-tools) 1.25.10.
  • Checked tokens shown as designed: 25 of 29 as tested.
  • VS Code has no built-in CMake grammar. Other CMake grammar extensions were not tested.
4 exceptions
Token Should be Shown as Why
add_fw function text the grammar scopes it exactly like 3.20 (number / constant).
BOARD global / config variable text CMake variable name in set() is unscoped.
C_STANDARD member / key text the grammar scopes it exactly like 3.20 (number / constant).
3.20 number / constant text the grammar scopes it exactly like add_fw (function).

JSON and JSONC

  • Grammar: built in.
  • Checked tokens shown as designed: 16 of 16 as tested.

No exceptions found.

YAML

  • Grammar: built in.
  • Checked tokens shown as designed: 29 of 31 as tested.
  • Tested with YAML (redhat.vscode-yaml) 2.0.0 installed. It provides no semantic tokens.
2 exceptions
Token Should be Shown as Why
2026-11-20 number / constant string the grammar scopes it exactly like esp32 (string).
? punctuation text YAML explicit-key ? gets only meta.block-mapping.yaml.

TOML

  • Grammar: Even Better TOML (tamasfe.even-better-toml) 0.21.2.
  • Checked tokens shown as designed: 24 of 24 without a language server; 24 of 24 with Even Better TOML.
  • The same extension provides the grammar and the semantic tokens.

No exceptions found.

INI

  • Grammar: built in.
  • Checked tokens shown as designed: 6 of 9 as tested.
3 exceptions
Token Should be Shown as Why
-DDEBUG member / key text the grammar scopes it exactly like espressif32 (string).
115200 number / constant text the grammar scopes it exactly like espressif32 (string).
espressif32 string text the grammar scopes it exactly like 115200 (number / constant).

Markdown

  • Grammar: built in.
  • Checked tokens shown as designed: 26 of 27 as tested.
  • Fenced code blocks use the grammar of their language, so the sections for those languages apply.
1 exception
Token Should be Shown as Why
Setext function text a setext heading line is a paragraph until the underline on the next line; TextMate cannot look ahead.

Log files

  • Grammar: built in, plus Rosin's own log-level grammar.
  • Checked tokens shown as designed: 19 of 22 as tested.
  • Rosin recognises ESP-IDF style (E (512) tag:) and Zephyr style (<err>) levels, panic and fault messages.
3 exceptions
Token Should be Shown as Why
Traceback, ValueError error text the grammar scopes it exactly like < (punctuation).
< punctuation text the grammar scopes it exactly like Traceback (error).

Diffs and git commit messages

  • Grammar: built in.
  • Checked tokens shown as designed: 25 of 26 as tested.
1 exception
Token Should be Shown as Why
src/main.c string keyword the grammar scopes it exactly like modified (keyword).

ARM assembly

  • Grammar: Arm Assembly (dan-c-underwood.arm) 1.7.4.
  • Checked tokens shown as designed: 26 of 31 as tested.
5 exceptions
Token Should be Shown as Why
main, Reset_Handler function text the grammar scopes it exactly like _estack (global / config variable).
_estack, STACK global / config variable text the grammar scopes it exactly like main (function).
.equ preprocessor / attribute text ARM .equ directive is unscoped in this grammar.

Linker scripts

  • Grammar: LinkerScript (ZixuanWang.linkerscript) 1.0.4.
  • Checked tokens shown as designed: 16 of 23 as tested.
7 exceptions
Token Should be Shown as Why
Reset_Handler function text the grammar scopes it exactly like 0x08000000 (number / constant).
. hazard text the location counter . is a bare variable.other.ld, the same scope as every other linker-script name.
0x08000000, 4096 number / constant text the grammar scopes it exactly like Reset_Handler (function).
rx qualifier text memory attributes (rx) and input-section patterns (.text*) share section.input.ld variable.other.ld; a rule was tried in E2 and reverted.
K unit text the grammar scopes it exactly like Reset_Handler (function).
FLASH user type keyword the grammar scopes it exactly like KEEP (keyword).

Devicetree

  • Grammar: DeviceTree (plorefice.devicetree) 0.1.1.
  • Checked tokens shown as designed: 9 of 15 as tested.
6 exceptions
Token Should be Shown as Why
\n escape string the grammar scopes it exactly like gpio-leds (string).
GPIO_ACTIVE_HIGH macro number / constant the grammar scopes it exactly like 13 (number / constant).
compatible, #address-cells member / key text the grammar scopes it exactly like /dts-v1/ (preprocessor / attribute).
/dts-v1/ preprocessor / attribute text the grammar scopes it exactly like compatible (member / key).
[ punctuation number / constant the grammar scopes it exactly like GPIO_ACTIVE_HIGH (macro).

Kconfig

  • Grammar: ESP-IDF (espressif.esp-idf-extension) 2.3.0.
  • Checked tokens shown as designed: 10 of 19 as tested.
  • The ESP-IDF extension provides the Kconfig grammar.
9 exceptions
Token Should be Shown as Why
Pin comment text the grammar scopes it exactly like BLINK_GPIO (global / config variable).
\" escape text the grammar scopes it exactly like BLINK_GPIO (global / config variable).
$( global / config variable string the grammar scopes it exactly like GPIO (string).
BLINK_GPIO, SOC_GPIO global / config variable text the grammar scopes it exactly like 48 (number / constant).
48 number / constant text the grammar scopes it exactly like BLINK_GPIO (global / config variable).
int, string, bool primitive type keyword the grammar scopes it exactly like range (keyword).

Every exception, with its evidence, is in the limits register. Tested on VS Code 1.147.0.

Install

  1. Open the Extensions view (Ctrl+Shift+X) and search for Rosin.
  2. Install it, then run Preferences: Color Theme and pick a Rosin · … flavour.

Offline or on a fork of VS Code? Download the .vsix from the latest release and run Extensions: Install from VSIX….

Recommended settings

"editor.semanticHighlighting.enabled": true,
"editor.bracketPairColorization.enabled": true

Install the language servers recommended under Language support for the languages you use. Without them, methods, library functions, globals and statics fall back to the function or text colour in C, C++, Rust and Python.

Building from source

The theme files are generated. To change a palette, edit the flavour tables in tools/gen.py, then run:

python tools/gen.py             # writes themes/*.json
python tools/readme_assets.py   # redraws the preview, swatches and colour tables (needs Pillow)
python tools/readme_languages.py   # rewrites the Language support section from the audit's limits register
npx @vscode/vsce package        # builds the .vsix

To release, bump version in package.json, add a CHANGELOG.md entry, then push a matching tag (git tag v1.0.2 && git push --tags). A GitHub Action builds the .vsix and attaches it to a new release.

License

MIT

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
© 2026 Microsoft