BranchesTags

Repository files navigation

important

It's extremely important to make your code understandable with plenty of comments

IMPORTANT Language Specification

version 1.0.1
Table of Contents
I. Preface
II. Principles
III. Grammar
IV. Examples
V. Implementations
VI. Acknowledgement

I. Preface

In order to prevent the imminent destructive battle between the world of programmers and ordinary people, and to bridge the gap in understanding between the two parties (from at least one side), we created a programming language that encourages programmers to write code that is fully understandable to anyone. We know that a mere tool alone would not be a solution to such a serious problem, so it is IMPORTANT to note that the IMPORTANT language is much more of an attitude-forming purpose than a practical one. Those who don't like that look for other languages, but who does, it's a hero.

II. Principles

It's IMPORTANT to comment and explain each and every piece of code in IMPORTANT, because it's IMPORTANT. See examples in section IV.

III. Grammar

3. Brief description

The IMPORTANT language is a somewhat extended version of brainfuck. It contains a stack with three operations associated with it in addition to standard bf operations. Out of the usual pop and push operations, the swap operation is also part of the language. Another IMPORTANT feature is that the IMPORTANT language supports comments, and they even play an extremely IMPORTANT role while running programs. It's almost magic.

2. Instruction set

CommandDescription
>Increment pointer
<Decrement pointer
+Increment byte at pointer
-Decrement byte at pointer
.Output byte at pointer
,Input byte and place it at pointer
ˇPush byte at pointer to the top of the stack
^Pop byte from the top of the stack and place it at pointer
;Swap byte at pointer with the byte on the top of the stack
{Jump to matching } if byte at pointer is zero
}Jump to matching { if byte at pointer is non zero
:text:Comment

IV. Examples

Small piece of code doing nothing:

:This code does nothing
because the pointer is zero when the program reaches the { curly bracket
so the - operation does not decreases the pointer instead it goes to the
closing } bracket and the program quits:
{-}

Small piece of code that does something:

:This program - called cat - writes its input directly to its output
Lets explain it briefly
, inputs data
{ finish program when there is zero data at pointer
. print data
, input data
} repeat this while there is nonzero data at pointer:
,{.,}

Piece of code that's not doing anything, because it isn't explained:

:This code is provided as-is and magically prints 'Hello World!' to the console:
+{-->-{>>+>-----<<}<--<---}>-.>>>+.>>..+++{.>}<<<<.+++.------.<<-.>>>>+.

V. Implementations

So far, we have not encountered further implementations of the language. If you did, open a pull request.

VI. Acknowledgement

Yet another empty space for now.

About

It's extremely important to make your code understandable with plenty of comments

Topics

compilerezoteric-languageimportantinterpreter

Resources

Readme
Unlicense
Activity

Stars

1 star

Watchers

1 watching

Forks

0 forks
Report repository

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
important
It's extremely important to make your code understandable with plenty of comments
IMPORTANT Language Specification
version 1.0.1
Table of Contents
I. Preface
II. Principles
III. Grammar
IV. Examples
V. Implementations
VI. Acknowledgement
I. Preface 
In order to prevent the imminent destructive battle between the world of programmers and ordinary people, and
to bridge the gap in understanding between the two parties (from at least one side), we created
a programming language that encourages programmers to write code that is fully understandable to anyone.
We know that a mere tool alone would not be a solution to such a serious problem, so it is IMPORTANT to note that
the IMPORTANT language is much more of an attitude-forming purpose than a practical one.
Those who don't like that look for other languages, but who does, it's a hero.
II. Principles 
It's IMPORTANT to comment and explain each and every piece of code in IMPORTANT, because it's IMPORTANT.
See examples in section IV.
III. Grammar 
3. Brief description
The IMPORTANT language is a somewhat extended version of brainfuck. It contains a stack with three operations associated
with it in addition to standard bf operations. Out of the usual pop and push operations, the swap operation is also
part of the language.
Another IMPORTANT feature is that the IMPORTANT language supports comments, and they even play an extremely IMPORTANT role
while running programs. It's almost magic.
2. Instruction set
CommandDescription
>Increment pointer
<Decrement pointer
+Increment byte at pointer
-Decrement byte at pointer
.Output byte at pointer
,Input byte and place it at pointer
ˇPush byte at pointer to the top of the stack
^Pop byte from the top of the stack and place it at pointer
;Swap byte at pointer with the byte on the top of the stack
{Jump to matching } if byte at pointer is zero
}Jump to matching { if byte at pointer is non zero
:text:Comment
IV. Examples 
Small piece of code doing nothing:
:This code does nothing
because the pointer is zero when the program reaches the { curly bracket
so the - operation does not decreases the pointer instead it goes to the
closing } bracket and the program quits:
{-}

Small piece of code that does something:
:This program - called cat - writes its input directly to its output
Lets explain it briefly
, inputs data
{ finish program when there is zero data at pointer
. print data
, input data
} repeat this while there is nonzero data at pointer:
,{.,}

Piece of code that's not doing anything, because it isn't explained:
:This code is provided as-is and magically prints 'Hello World!' to the console:
+{-->-{>>+>-----<<}<--<---}>-.>>>+.>>..+++{.>}<<<<.+++.------.<<-.>>>>+.

V. Implementations 
So far, we have not encountered further implementations of the language. If you did, open a pull request.
VI. Acknowledgement 
Yet another empty space for now.
About
It's extremely important to make your code understandable with plenty of comments
Topics
compilerezoteric-languageimportantinterpreter
Resources
Readme
Unlicense
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
important
It's extremely important to make your code understandable with plenty of comments
IMPORTANT Language Specification
version 1.0.1
Table of Contents
I. Preface
II. Principles
III. Grammar
IV. Examples
V. Implementations
VI. Acknowledgement
I. Preface 
In order to prevent the imminent destructive battle between the world of programmers and ordinary people, and
to bridge the gap in understanding between the two parties (from at least one side), we created
a programming language that encourages programmers to write code that is fully understandable to anyone.
We know that a mere tool alone would not be a solution to such a serious problem, so it is IMPORTANT to note that
the IMPORTANT language is much more of an attitude-forming purpose than a practical one.
Those who don't like that look for other languages, but who does, it's a hero.
II. Principles 
It's IMPORTANT to comment and explain each and every piece of code in IMPORTANT, because it's IMPORTANT.
See examples in section IV.
III. Grammar 
3. Brief description
The IMPORTANT language is a somewhat extended version of brainfuck. It contains a stack with three operations associated
with it in addition to standard bf operations. Out of the usual pop and push operations, the swap operation is also
part of the language.
Another IMPORTANT feature is that the IMPORTANT language supports comments, and they even play an extremely IMPORTANT role
while running programs. It's almost magic.
2. Instruction set
CommandDescription
>Increment pointer
<Decrement pointer
+Increment byte at pointer
-Decrement byte at pointer
.Output byte at pointer
,Input byte and place it at pointer
ˇPush byte at pointer to the top of the stack
^Pop byte from the top of the stack and place it at pointer
;Swap byte at pointer with the byte on the top of the stack
{Jump to matching } if byte at pointer is zero
}Jump to matching { if byte at pointer is non zero
:text:Comment
IV. Examples 
Small piece of code doing nothing:
:This code does nothing
because the pointer is zero when the program reaches the { curly bracket
so the - operation does not decreases the pointer instead it goes to the
closing } bracket and the program quits:
{-}

Small piece of code that does something:
:This program - called cat - writes its input directly to its output
Lets explain it briefly
, inputs data
{ finish program when there is zero data at pointer
. print data
, input data
} repeat this while there is nonzero data at pointer:
,{.,}

Piece of code that's not doing anything, because it isn't explained:
:This code is provided as-is and magically prints 'Hello World!' to the console:
+{-->-{>>+>-----<<}<--<---}>-.>>>+.>>..+++{.>}<<<<.+++.------.<<-.>>>>+.

V. Implementations 
So far, we have not encountered further implementations of the language. If you did, open a pull request.
VI. Acknowledgement 
Yet another empty space for now.
About
It's extremely important to make your code understandable with plenty of comments
Topics
compilerezoteric-languageimportantinterpreter
Resources
Readme
Unlicense
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
important
It's extremely important to make your code understandable with plenty of comments
IMPORTANT Language Specification
version 1.0.1
Table of Contents
I. Preface
II. Principles
III. Grammar
IV. Examples
V. Implementations
VI. Acknowledgement
I. Preface 
In order to prevent the imminent destructive battle between the world of programmers and ordinary people, and
to bridge the gap in understanding between the two parties (from at least one side), we created
a programming language that encourages programmers to write code that is fully understandable to anyone.
We know that a mere tool alone would not be a solution to such a serious problem, so it is IMPORTANT to note that
the IMPORTANT language is much more of an attitude-forming purpose than a practical one.
Those who don't like that look for other languages, but who does, it's a hero.
II. Principles 
It's IMPORTANT to comment and explain each and every piece of code in IMPORTANT, because it's IMPORTANT.
See examples in section IV.
III. Grammar 
3. Brief description
The IMPORTANT language is a somewhat extended version of brainfuck. It contains a stack with three operations associated
with it in addition to standard bf operations. Out of the usual pop and push operations, the swap operation is also
part of the language.
Another IMPORTANT feature is that the IMPORTANT language supports comments, and they even play an extremely IMPORTANT role
while running programs. It's almost magic.
2. Instruction set
CommandDescription
>Increment pointer
<Decrement pointer
+Increment byte at pointer
-Decrement byte at pointer
.Output byte at pointer
,Input byte and place it at pointer
ˇPush byte at pointer to the top of the stack
^Pop byte from the top of the stack and place it at pointer
;Swap byte at pointer with the byte on the top of the stack
{Jump to matching } if byte at pointer is zero
}Jump to matching { if byte at pointer is non zero
:text:Comment
IV. Examples 
Small piece of code doing nothing:
:This code does nothing
because the pointer is zero when the program reaches the { curly bracket
so the - operation does not decreases the pointer instead it goes to the
closing } bracket and the program quits:
{-}

Small piece of code that does something:
:This program - called cat - writes its input directly to its output
Lets explain it briefly
, inputs data
{ finish program when there is zero data at pointer
. print data
, input data
} repeat this while there is nonzero data at pointer:
,{.,}

Piece of code that's not doing anything, because it isn't explained:
:This code is provided as-is and magically prints 'Hello World!' to the console:
+{-->-{>>+>-----<<}<--<---}>-.>>>+.>>..+++{.>}<<<<.+++.------.<<-.>>>>+.

V. Implementations 
So far, we have not encountered further implementations of the language. If you did, open a pull request.
VI. Acknowledgement 
Yet another empty space for now.
About
It's extremely important to make your code understandable with plenty of comments
Topics
compilerezoteric-languageimportantinterpreter
Resources
Readme
Unlicense
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
important
It's extremely important to make your code understandable with plenty of comments
IMPORTANT Language Specification
version 1.0.1
Table of Contents
I. Preface
II. Principles
III. Grammar
IV. Examples
V. Implementations
VI. Acknowledgement
I. Preface 
In order to prevent the imminent destructive battle between the world of programmers and ordinary people, and
to bridge the gap in understanding between the two parties (from at least one side), we created
a programming language that encourages programmers to write code that is fully understandable to anyone.
We know that a mere tool alone would not be a solution to such a serious problem, so it is IMPORTANT to note that
the IMPORTANT language is much more of an attitude-forming purpose than a practical one.
Those who don't like that look for other languages, but who does, it's a hero.
II. Principles 
It's IMPORTANT to comment and explain each and every piece of code in IMPORTANT, because it's IMPORTANT.
See examples in section IV.
III. Grammar 
3. Brief description
The IMPORTANT language is a somewhat extended version of brainfuck. It contains a stack with three operations associated
with it in addition to standard bf operations. Out of the usual pop and push operations, the swap operation is also
part of the language.
Another IMPORTANT feature is that the IMPORTANT language supports comments, and they even play an extremely IMPORTANT role
while running programs. It's almost magic.
2. Instruction set
CommandDescription
>Increment pointer
<Decrement pointer
+Increment byte at pointer
-Decrement byte at pointer
.Output byte at pointer
,Input byte and place it at pointer
ˇPush byte at pointer to the top of the stack
^Pop byte from the top of the stack and place it at pointer
;Swap byte at pointer with the byte on the top of the stack
{Jump to matching } if byte at pointer is zero
}Jump to matching { if byte at pointer is non zero
:text:Comment
IV. Examples 
Small piece of code doing nothing:
:This code does nothing
because the pointer is zero when the program reaches the { curly bracket
so the - operation does not decreases the pointer instead it goes to the
closing } bracket and the program quits:
{-}

Small piece of code that does something:
:This program - called cat - writes its input directly to its output
Lets explain it briefly
, inputs data
{ finish program when there is zero data at pointer
. print data
, input data
} repeat this while there is nonzero data at pointer:
,{.,}

Piece of code that's not doing anything, because it isn't explained:
:This code is provided as-is and magically prints 'Hello World!' to the console:
+{-->-{>>+>-----<<}<--<---}>-.>>>+.>>..+++{.>}<<<<.+++.------.<<-.>>>>+.

V. Implementations 
So far, we have not encountered further implementations of the language. If you did, open a pull request.
VI. Acknowledgement 
Yet another empty space for now.
About
It's extremely important to make your code understandable with plenty of comments
Topics
compilerezoteric-languageimportantinterpreter
Resources
Readme
Unlicense
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
important
It's extremely important to make your code understandable with plenty of comments
IMPORTANT Language Specification
version 1.0.1
Table of Contents
I. Preface
II. Principles
III. Grammar
IV. Examples
V. Implementations
VI. Acknowledgement
I. Preface 
In order to prevent the imminent destructive battle between the world of programmers and ordinary people, and
to bridge the gap in understanding between the two parties (from at least one side), we created
a programming language that encourages programmers to write code that is fully understandable to anyone.
We know that a mere tool alone would not be a solution to such a serious problem, so it is IMPORTANT to note that
the IMPORTANT language is much more of an attitude-forming purpose than a practical one.
Those who don't like that look for other languages, but who does, it's a hero.
II. Principles 
It's IMPORTANT to comment and explain each and every piece of code in IMPORTANT, because it's IMPORTANT.
See examples in section IV.
III. Grammar 
3. Brief description
The IMPORTANT language is a somewhat extended version of brainfuck. It contains a stack with three operations associated
with it in addition to standard bf operations. Out of the usual pop and push operations, the swap operation is also
part of the language.
Another IMPORTANT feature is that the IMPORTANT language supports comments, and they even play an extremely IMPORTANT role
while running programs. It's almost magic.
2. Instruction set
CommandDescription
>Increment pointer
<Decrement pointer
+Increment byte at pointer
-Decrement byte at pointer
.Output byte at pointer
,Input byte and place it at pointer
ˇPush byte at pointer to the top of the stack
^Pop byte from the top of the stack and place it at pointer
;Swap byte at pointer with the byte on the top of the stack
{Jump to matching } if byte at pointer is zero
}Jump to matching { if byte at pointer is non zero
:text:Comment
IV. Examples 
Small piece of code doing nothing:
:This code does nothing
because the pointer is zero when the program reaches the { curly bracket
so the - operation does not decreases the pointer instead it goes to the
closing } bracket and the program quits:
{-}

Small piece of code that does something:
:This program - called cat - writes its input directly to its output
Lets explain it briefly
, inputs data
{ finish program when there is zero data at pointer
. print data
, input data
} repeat this while there is nonzero data at pointer:
,{.,}

Piece of code that's not doing anything, because it isn't explained:
:This code is provided as-is and magically prints 'Hello World!' to the console:
+{-->-{>>+>-----<<}<--<---}>-.>>>+.>>..+++{.>}<<<<.+++.------.<<-.>>>>+.

V. Implementations 
So far, we have not encountered further implementations of the language. If you did, open a pull request.
VI. Acknowledgement 
Yet another empty space for now.
About
It's extremely important to make your code understandable with plenty of comments
Topics
compilerezoteric-languageimportantinterpreter
Resources
Readme
Unlicense
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
important
It's extremely important to make your code understandable with plenty of comments
IMPORTANT Language Specification
version 1.0.1
Table of Contents
I. Preface
II. Principles
III. Grammar
IV. Examples
V. Implementations
VI. Acknowledgement
I. Preface 
In order to prevent the imminent destructive battle between the world of programmers and ordinary people, and
to bridge the gap in understanding between the two parties (from at least one side), we created
a programming language that encourages programmers to write code that is fully understandable to anyone.
We know that a mere tool alone would not be a solution to such a serious problem, so it is IMPORTANT to note that
the IMPORTANT language is much more of an attitude-forming purpose than a practical one.
Those who don't like that look for other languages, but who does, it's a hero.
II. Principles 
It's IMPORTANT to comment and explain each and every piece of code in IMPORTANT, because it's IMPORTANT.
See examples in section IV.
III. Grammar 
3. Brief description
The IMPORTANT language is a somewhat extended version of brainfuck. It contains a stack with three operations associated
with it in addition to standard bf operations. Out of the usual pop and push operations, the swap operation is also
part of the language.
Another IMPORTANT feature is that the IMPORTANT language supports comments, and they even play an extremely IMPORTANT role
while running programs. It's almost magic.
2. Instruction set
CommandDescription
>Increment pointer
<Decrement pointer
+Increment byte at pointer
-Decrement byte at pointer
.Output byte at pointer
,Input byte and place it at pointer
ˇPush byte at pointer to the top of the stack
^Pop byte from the top of the stack and place it at pointer
;Swap byte at pointer with the byte on the top of the stack
{Jump to matching } if byte at pointer is zero
}Jump to matching { if byte at pointer is non zero
:text:Comment
IV. Examples 
Small piece of code doing nothing:
:This code does nothing
because the pointer is zero when the program reaches the { curly bracket
so the - operation does not decreases the pointer instead it goes to the
closing } bracket and the program quits:
{-}

Small piece of code that does something:
:This program - called cat - writes its input directly to its output
Lets explain it briefly
, inputs data
{ finish program when there is zero data at pointer
. print data
, input data
} repeat this while there is nonzero data at pointer:
,{.,}

Piece of code that's not doing anything, because it isn't explained:
:This code is provided as-is and magically prints 'Hello World!' to the console:
+{-->-{>>+>-----<<}<--<---}>-.>>>+.>>..+++{.>}<<<<.+++.------.<<-.>>>>+.

V. Implementations 
So far, we have not encountered further implementations of the language. If you did, open a pull request.
VI. Acknowledgement 
Yet another empty space for now.
About
It's extremely important to make your code understandable with plenty of comments
Topics
compilerezoteric-languageimportantinterpreter
Resources
Readme
Unlicense
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
important
It's extremely important to make your code understandable with plenty of comments
IMPORTANT Language Specification
version 1.0.1
Table of Contents
I. Preface
II. Principles
III. Grammar
IV. Examples
V. Implementations
VI. Acknowledgement
I. Preface 
In order to prevent the imminent destructive battle between the world of programmers and ordinary people, and
to bridge the gap in understanding between the two parties (from at least one side), we created
a programming language that encourages programmers to write code that is fully understandable to anyone.
We know that a mere tool alone would not be a solution to such a serious problem, so it is IMPORTANT to note that
the IMPORTANT language is much more of an attitude-forming purpose than a practical one.
Those who don't like that look for other languages, but who does, it's a hero.
II. Principles 
It's IMPORTANT to comment and explain each and every piece of code in IMPORTANT, because it's IMPORTANT.
See examples in section IV.
III. Grammar 
3. Brief description
The IMPORTANT language is a somewhat extended version of brainfuck. It contains a stack with three operations associated
with it in addition to standard bf operations. Out of the usual pop and push operations, the swap operation is also
part of the language.
Another IMPORTANT feature is that the IMPORTANT language supports comments, and they even play an extremely IMPORTANT role
while running programs. It's almost magic.
2. Instruction set
CommandDescription
>Increment pointer
<Decrement pointer
+Increment byte at pointer
-Decrement byte at pointer
.Output byte at pointer
,Input byte and place it at pointer
ˇPush byte at pointer to the top of the stack
^Pop byte from the top of the stack and place it at pointer
;Swap byte at pointer with the byte on the top of the stack
{Jump to matching } if byte at pointer is zero
}Jump to matching { if byte at pointer is non zero
:text:Comment
IV. Examples 
Small piece of code doing nothing:
:This code does nothing
because the pointer is zero when the program reaches the { curly bracket
so the - operation does not decreases the pointer instead it goes to the
closing } bracket and the program quits:
{-}

Small piece of code that does something:
:This program - called cat - writes its input directly to its output
Lets explain it briefly
, inputs data
{ finish program when there is zero data at pointer
. print data
, input data
} repeat this while there is nonzero data at pointer:
,{.,}

Piece of code that's not doing anything, because it isn't explained:
:This code is provided as-is and magically prints 'Hello World!' to the console:
+{-->-{>>+>-----<<}<--<---}>-.>>>+.>>..+++{.>}<<<<.+++.------.<<-.>>>>+.

V. Implementations 
So far, we have not encountered further implementations of the language. If you did, open a pull request.
VI. Acknowledgement 
Yet another empty space for now.
About
It's extremely important to make your code understandable with plenty of comments
Topics
compilerezoteric-languageimportantinterpreter
Resources
Readme
Unlicense
Activity
Stars
1 star
Watchers
1 watching
Forks
0 forks
Report repository
Contributors
Languages