BranchesTags

Repository files navigation

Pugl

Pugl (PlUgin Graphics Library) is a minimal portability layer for GUIs which is suitable for use in plugins and applications. It works on X11, MacOS, and Windows, and includes optional support for drawing with Vulkan, OpenGL, and Cairo.

Pugl is vaguely similar to libraries like GLUT and GLFW, but has different goals and priorities:

  • Minimal in scope, providing only a thin interface to isolate platform-specific details from applications.

  • Zero dependencies, aside from standard system libraries.

  • Support for embedding in native windows, for example as a plugin or component within a larger application that is not based on Pugl.

  • Explicit context and no static data, so that several instances can be used within a single program at once.

  • Consistent event-based API that makes dispatching in application or toolkit code easy with minimal boilerplate.

  • Suitable for both continuously rendering applications like games, and event-driven applications that only draw when necessary.

  • Well-integrated with windowing systems, with support for tracking and manipulating special window types, states, and styles.

  • Small, liberally licensed implementation that is suitable for vendoring and/or static linking. Pugl can be installed as a library, or used by simply copying the implementation into a project.

Stability

Pugl is currently being developed towards a long-term stable API. For the time being, however, the API may break occasionally. Please report any relevant feedback, or file feature requests, so that we can ensure that the released API is stable for as long as possible.

When the API changes, backwards compatibility is maintained where possible. These compatibility shims will be removed before release, so users are encouraged to build with PUGL_DISABLE_DEPRECATED defined.

Documentation

Pugl is a C library that includes C++ bindings. The reference documentation refers to the C API:

The documentation will also be built from the source if the docs configuration option is enabled, and both Doxygen and Sphinx are available.

The C++ documentation is currently a work in progress, for now you will have to refer to the examples or headers for guidance on using the C++ bindings.

Testing

Some unit tests are included, but unfortunately manual testing is still required. The tests and example programs are built by default. You can run all the tests at once via ninja:

meson setup build
cd build
ninja test

The examples directory contains several demonstration programs that can be used for manual testing.

-- David Robillard d@drobilla.net

About

A minimal portable API for embeddable GUIs

gitlab.com/lv2/pugl/

Resources

Readme
ISC license
Activity
Custom properties

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n 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;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} 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
Pugl
Pugl (PlUgin Graphics Library) is a minimal portability layer for GUIs which is
suitable for use in plugins and applications. It works on X11, MacOS, and
Windows, and includes optional support for drawing with Vulkan, OpenGL, and
Cairo.
Pugl is vaguely similar to libraries like GLUT and GLFW, but has different
goals and priorities:
  • Minimal in scope, providing only a thin interface to isolate
platform-specific details from applications.
  • Zero dependencies, aside from standard system libraries.
  • Support for embedding in native windows, for example as a plugin or
component within a larger application that is not based on Pugl.
  • Explicit context and no static data, so that several instances can be used
within a single program at once.
  • Consistent event-based API that makes dispatching in application or toolkit
code easy with minimal boilerplate.
  • Suitable for both continuously rendering applications like games, and
event-driven applications that only draw when necessary.
  • Well-integrated with windowing systems, with support for tracking and
manipulating special window types, states, and styles.
  • Small, liberally licensed implementation that is suitable for vendoring
and/or static linking. Pugl can be installed as a library, or used by
simply copying the implementation into a project.
Stability
Pugl is currently being developed towards a long-term stable API. For the time
being, however, the API may break occasionally. Please report any relevant
feedback, or file feature requests, so that we can ensure that the released API
is stable for as long as possible.
When the API changes, backwards compatibility is maintained where possible.
These compatibility shims will be removed before release, so users are
encouraged to build with PUGL_DISABLE_DEPRECATED defined.
Documentation
Pugl is a C library that includes C++ bindings.
The reference documentation refers to the C API:
The documentation will also be built from the source if the docs
configuration option is enabled, and both Doxygen and Sphinx are available.
The C++ documentation is currently a work in progress, for now you will have to
refer to the examples or headers for guidance on using the C++ bindings.
Testing
Some unit tests are included, but unfortunately manual testing is still
required. The tests and example programs are built by default. You can run
all the tests at once via ninja:
meson setup build
cd build
ninja test

The examples directory contains several demonstration programs that
can be used for manual testing.
-- David Robillard d@drobilla.net
About
A minimal portable API for embeddable GUIs
gitlab.com/lv2/pugl/
Resources
Readme
ISC license
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} 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
Pugl
Pugl (PlUgin Graphics Library) is a minimal portability layer for GUIs which is
suitable for use in plugins and applications. It works on X11, MacOS, and
Windows, and includes optional support for drawing with Vulkan, OpenGL, and
Cairo.
Pugl is vaguely similar to libraries like GLUT and GLFW, but has different
goals and priorities:
  • Minimal in scope, providing only a thin interface to isolate
platform-specific details from applications.
  • Zero dependencies, aside from standard system libraries.
  • Support for embedding in native windows, for example as a plugin or
component within a larger application that is not based on Pugl.
  • Explicit context and no static data, so that several instances can be used
within a single program at once.
  • Consistent event-based API that makes dispatching in application or toolkit
code easy with minimal boilerplate.
  • Suitable for both continuously rendering applications like games, and
event-driven applications that only draw when necessary.
  • Well-integrated with windowing systems, with support for tracking and
manipulating special window types, states, and styles.
  • Small, liberally licensed implementation that is suitable for vendoring
and/or static linking. Pugl can be installed as a library, or used by
simply copying the implementation into a project.
Stability
Pugl is currently being developed towards a long-term stable API. For the time
being, however, the API may break occasionally. Please report any relevant
feedback, or file feature requests, so that we can ensure that the released API
is stable for as long as possible.
When the API changes, backwards compatibility is maintained where possible.
These compatibility shims will be removed before release, so users are
encouraged to build with PUGL_DISABLE_DEPRECATED defined.
Documentation
Pugl is a C library that includes C++ bindings.
The reference documentation refers to the C API:
The documentation will also be built from the source if the docs
configuration option is enabled, and both Doxygen and Sphinx are available.
The C++ documentation is currently a work in progress, for now you will have to
refer to the examples or headers for guidance on using the C++ bindings.
Testing
Some unit tests are included, but unfortunately manual testing is still
required. The tests and example programs are built by default. You can run
all the tests at once via ninja:
meson setup build
cd build
ninja test

The examples directory contains several demonstration programs that
can be used for manual testing.
-- David Robillard d@drobilla.net
About
A minimal portable API for embeddable GUIs
gitlab.com/lv2/pugl/
Resources
Readme
ISC license
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

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

Skip to content
BranchesTags
Repository files navigation
Pugl
Pugl (PlUgin Graphics Library) is a minimal portability layer for GUIs which is
suitable for use in plugins and applications. It works on X11, MacOS, and
Windows, and includes optional support for drawing with Vulkan, OpenGL, and
Cairo.
Pugl is vaguely similar to libraries like GLUT and GLFW, but has different
goals and priorities:
  • Minimal in scope, providing only a thin interface to isolate
platform-specific details from applications.
  • Zero dependencies, aside from standard system libraries.
  • Support for embedding in native windows, for example as a plugin or
component within a larger application that is not based on Pugl.
  • Explicit context and no static data, so that several instances can be used
within a single program at once.
  • Consistent event-based API that makes dispatching in application or toolkit
code easy with minimal boilerplate.
  • Suitable for both continuously rendering applications like games, and
event-driven applications that only draw when necessary.
  • Well-integrated with windowing systems, with support for tracking and
manipulating special window types, states, and styles.
  • Small, liberally licensed implementation that is suitable for vendoring
and/or static linking. Pugl can be installed as a library, or used by
simply copying the implementation into a project.
Stability
Pugl is currently being developed towards a long-term stable API. For the time
being, however, the API may break occasionally. Please report any relevant
feedback, or file feature requests, so that we can ensure that the released API
is stable for as long as possible.
When the API changes, backwards compatibility is maintained where possible.
These compatibility shims will be removed before release, so users are
encouraged to build with PUGL_DISABLE_DEPRECATED defined.
Documentation
Pugl is a C library that includes C++ bindings.
The reference documentation refers to the C API:
The documentation will also be built from the source if the docs
configuration option is enabled, and both Doxygen and Sphinx are available.
The C++ documentation is currently a work in progress, for now you will have to
refer to the examples or headers for guidance on using the C++ bindings.
Testing
Some unit tests are included, but unfortunately manual testing is still
required. The tests and example programs are built by default. You can run
all the tests at once via ninja:
meson setup build
cd build
ninja test

The examples directory contains several demonstration programs that
can be used for manual testing.
-- David Robillard d@drobilla.net
About
A minimal portable API for embeddable GUIs
gitlab.com/lv2/pugl/
Resources
Readme
ISC license
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} 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
Pugl
Pugl (PlUgin Graphics Library) is a minimal portability layer for GUIs which is
suitable for use in plugins and applications. It works on X11, MacOS, and
Windows, and includes optional support for drawing with Vulkan, OpenGL, and
Cairo.
Pugl is vaguely similar to libraries like GLUT and GLFW, but has different
goals and priorities:
  • Minimal in scope, providing only a thin interface to isolate
platform-specific details from applications.
  • Zero dependencies, aside from standard system libraries.
  • Support for embedding in native windows, for example as a plugin or
component within a larger application that is not based on Pugl.
  • Explicit context and no static data, so that several instances can be used
within a single program at once.
  • Consistent event-based API that makes dispatching in application or toolkit
code easy with minimal boilerplate.
  • Suitable for both continuously rendering applications like games, and
event-driven applications that only draw when necessary.
  • Well-integrated with windowing systems, with support for tracking and
manipulating special window types, states, and styles.
  • Small, liberally licensed implementation that is suitable for vendoring
and/or static linking. Pugl can be installed as a library, or used by
simply copying the implementation into a project.
Stability
Pugl is currently being developed towards a long-term stable API. For the time
being, however, the API may break occasionally. Please report any relevant
feedback, or file feature requests, so that we can ensure that the released API
is stable for as long as possible.
When the API changes, backwards compatibility is maintained where possible.
These compatibility shims will be removed before release, so users are
encouraged to build with PUGL_DISABLE_DEPRECATED defined.
Documentation
Pugl is a C library that includes C++ bindings.
The reference documentation refers to the C API:
The documentation will also be built from the source if the docs
configuration option is enabled, and both Doxygen and Sphinx are available.
The C++ documentation is currently a work in progress, for now you will have to
refer to the examples or headers for guidance on using the C++ bindings.
Testing
Some unit tests are included, but unfortunately manual testing is still
required. The tests and example programs are built by default. You can run
all the tests at once via ninja:
meson setup build
cd build
ninja test

The examples directory contains several demonstration programs that
can be used for manual testing.
-- David Robillard d@drobilla.net
About
A minimal portable API for embeddable GUIs
gitlab.com/lv2/pugl/
Resources
Readme
ISC license
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} 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
Pugl
Pugl (PlUgin Graphics Library) is a minimal portability layer for GUIs which is
suitable for use in plugins and applications. It works on X11, MacOS, and
Windows, and includes optional support for drawing with Vulkan, OpenGL, and
Cairo.
Pugl is vaguely similar to libraries like GLUT and GLFW, but has different
goals and priorities:
  • Minimal in scope, providing only a thin interface to isolate
platform-specific details from applications.
  • Zero dependencies, aside from standard system libraries.
  • Support for embedding in native windows, for example as a plugin or
component within a larger application that is not based on Pugl.
  • Explicit context and no static data, so that several instances can be used
within a single program at once.
  • Consistent event-based API that makes dispatching in application or toolkit
code easy with minimal boilerplate.
  • Suitable for both continuously rendering applications like games, and
event-driven applications that only draw when necessary.
  • Well-integrated with windowing systems, with support for tracking and
manipulating special window types, states, and styles.
  • Small, liberally licensed implementation that is suitable for vendoring
and/or static linking. Pugl can be installed as a library, or used by
simply copying the implementation into a project.
Stability
Pugl is currently being developed towards a long-term stable API. For the time
being, however, the API may break occasionally. Please report any relevant
feedback, or file feature requests, so that we can ensure that the released API
is stable for as long as possible.
When the API changes, backwards compatibility is maintained where possible.
These compatibility shims will be removed before release, so users are
encouraged to build with PUGL_DISABLE_DEPRECATED defined.
Documentation
Pugl is a C library that includes C++ bindings.
The reference documentation refers to the C API:
The documentation will also be built from the source if the docs
configuration option is enabled, and both Doxygen and Sphinx are available.
The C++ documentation is currently a work in progress, for now you will have to
refer to the examples or headers for guidance on using the C++ bindings.
Testing
Some unit tests are included, but unfortunately manual testing is still
required. The tests and example programs are built by default. You can run
all the tests at once via ninja:
meson setup build
cd build
ninja test

The examples directory contains several demonstration programs that
can be used for manual testing.
-- David Robillard d@drobilla.net
About
A minimal portable API for embeddable GUIs
gitlab.com/lv2/pugl/
Resources
Readme
ISC license
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

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

Skip to content
BranchesTags
Repository files navigation
Pugl
Pugl (PlUgin Graphics Library) is a minimal portability layer for GUIs which is
suitable for use in plugins and applications. It works on X11, MacOS, and
Windows, and includes optional support for drawing with Vulkan, OpenGL, and
Cairo.
Pugl is vaguely similar to libraries like GLUT and GLFW, but has different
goals and priorities:
  • Minimal in scope, providing only a thin interface to isolate
platform-specific details from applications.
  • Zero dependencies, aside from standard system libraries.
  • Support for embedding in native windows, for example as a plugin or
component within a larger application that is not based on Pugl.
  • Explicit context and no static data, so that several instances can be used
within a single program at once.
  • Consistent event-based API that makes dispatching in application or toolkit
code easy with minimal boilerplate.
  • Suitable for both continuously rendering applications like games, and
event-driven applications that only draw when necessary.
  • Well-integrated with windowing systems, with support for tracking and
manipulating special window types, states, and styles.
  • Small, liberally licensed implementation that is suitable for vendoring
and/or static linking. Pugl can be installed as a library, or used by
simply copying the implementation into a project.
Stability
Pugl is currently being developed towards a long-term stable API. For the time
being, however, the API may break occasionally. Please report any relevant
feedback, or file feature requests, so that we can ensure that the released API
is stable for as long as possible.
When the API changes, backwards compatibility is maintained where possible.
These compatibility shims will be removed before release, so users are
encouraged to build with PUGL_DISABLE_DEPRECATED defined.
Documentation
Pugl is a C library that includes C++ bindings.
The reference documentation refers to the C API:
The documentation will also be built from the source if the docs
configuration option is enabled, and both Doxygen and Sphinx are available.
The C++ documentation is currently a work in progress, for now you will have to
refer to the examples or headers for guidance on using the C++ bindings.
Testing
Some unit tests are included, but unfortunately manual testing is still
required. The tests and example programs are built by default. You can run
all the tests at once via ninja:
meson setup build
cd build
ninja test

The examples directory contains several demonstration programs that
can be used for manual testing.
-- David Robillard d@drobilla.net
About
A minimal portable API for embeddable GUIs
gitlab.com/lv2/pugl/
Resources
Readme
ISC license
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

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

Skip to content
BranchesTags
Repository files navigation
Pugl
Pugl (PlUgin Graphics Library) is a minimal portability layer for GUIs which is
suitable for use in plugins and applications. It works on X11, MacOS, and
Windows, and includes optional support for drawing with Vulkan, OpenGL, and
Cairo.
Pugl is vaguely similar to libraries like GLUT and GLFW, but has different
goals and priorities:
  • Minimal in scope, providing only a thin interface to isolate
platform-specific details from applications.
  • Zero dependencies, aside from standard system libraries.
  • Support for embedding in native windows, for example as a plugin or
component within a larger application that is not based on Pugl.
  • Explicit context and no static data, so that several instances can be used
within a single program at once.
  • Consistent event-based API that makes dispatching in application or toolkit
code easy with minimal boilerplate.
  • Suitable for both continuously rendering applications like games, and
event-driven applications that only draw when necessary.
  • Well-integrated with windowing systems, with support for tracking and
manipulating special window types, states, and styles.
  • Small, liberally licensed implementation that is suitable for vendoring
and/or static linking. Pugl can be installed as a library, or used by
simply copying the implementation into a project.
Stability
Pugl is currently being developed towards a long-term stable API. For the time
being, however, the API may break occasionally. Please report any relevant
feedback, or file feature requests, so that we can ensure that the released API
is stable for as long as possible.
When the API changes, backwards compatibility is maintained where possible.
These compatibility shims will be removed before release, so users are
encouraged to build with PUGL_DISABLE_DEPRECATED defined.
Documentation
Pugl is a C library that includes C++ bindings.
The reference documentation refers to the C API:
The documentation will also be built from the source if the docs
configuration option is enabled, and both Doxygen and Sphinx are available.
The C++ documentation is currently a work in progress, for now you will have to
refer to the examples or headers for guidance on using the C++ bindings.
Testing
Some unit tests are included, but unfortunately manual testing is still
required. The tests and example programs are built by default. You can run
all the tests at once via ninja:
meson setup build
cd build
ninja test

The examples directory contains several demonstration programs that
can be used for manual testing.
-- David Robillard d@drobilla.net
About
A minimal portable API for embeddable GUIs
gitlab.com/lv2/pugl/
Resources
Readme
ISC license
Activity
Custom properties
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages