Skip to content
BranchesTags

Repository files navigation

ExportWebAssembly

This package is very experimental.

The main purpose of this package is to generate WebAssembly and/or JavaScript from Julia code.

Example:

myfun(x) =sum((x, x, 1.0))
irgen(myfun, Tuple{Float64})) # look at the LLVM IR generatedwrite_wasm("myfun.wasm", myfun, Tuple{Float64})
wasm2wast("myfun.wasm") # look at the textual representation

This generates a WebAssembly file. The conversion to a binary WASM file uses LLVM's llc and lld.

WebAssembly is a new standard for running compiled code in a web browser. If Julia can generate WebAssembly, it opens up many opportunities to embed Julia "apps" in web interfaces. Julia is well positioned here because Julia can already compile efficient LLVM bitcode.

I have explored several approaches to generate WebAssembly. The two most promising approaches to generate WebAssembly are outlined as follows.

  1. CUDAnative approach – That's the approach in the master branch of this repository. It uses code from the CUDAnative package to produce LLVM bitcode on the fly. It works great for simple code (type stable code with no use of libjulia or other C functions). Math code that uses immutable structs and/or StaticArrays works well with this approach. The main downside is that it is so limited–-no arrays, no strings, no IO, etc. This approach could be extended to substitute out libjulia-type functions with equivalents that work in JavaScript/WebAssembly. For example, this crude example shows a custom array type that could work with WebAssembly. The main steps necessary to extend this approach are: (1) write a package to create WebAssembly-friendly versions of basic Julia types and operations (Dicts, Strings, Arrays, and printing) and (2) use the Cassette package or another approach to replace standard Julia dispatches involving these basic types with the WebAssembly-friendly versions.

  2. CodeGen.jl approach – The codegen-jl branch of this repository uses this approach. The CodeGen package uses the LLVM package to directly generate bitcode based on code_typed Julia code. This can use libjulia functions (also compiled to LLVM bitcode), so a wider range of Julia code may work. Some decently complex code runs, including some simple array creation and manipulation. But, there are still many gaps that need to be filled in here to be able to run Julia code in general. The main work with this approach is in upgrading the CodeGen package to support more Julia code. This method offers the most control over code generation and may allow the widest Julia code coverage (including code that links to C and Fortran libraries). It may also be wise to swap out libjulia methods with WebAssembly-focused versions. This could limit code size and allow easier integration.

Both of these approaches are on hold (as of March 2018) pending updates to Julia v0.7/1.0. These has been a lot of change in Julia related to the internal representation (IR) and how to access code generation. LLVM may also be upgraded as part of the transition to v1.0.

Right now, this repo only works with Julia v0.7dev master.

About

[WIP] Export Julia functions to WebAssembly and JavaScript

Resources

Readme
License
Activity

Stars

23 stars

Watchers

8 watching

Forks

3 forks
Report repository

Releases

Packages

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" + '
GitHub - tshort/ExportWebAssembly.jl: [WIP] Export Julia functions to WebAssembly and JavaScript · GitHub
Skip to content
BranchesTags
Repository files navigation
ExportWebAssembly
This package is very experimental.
The main purpose of this package is to generate WebAssembly and/or JavaScript from Julia code.
Example:
myfun(x) =sum((x, x, 1.0))
irgen(myfun, Tuple{Float64})) # look at the LLVM IR generatedwrite_wasm("myfun.wasm", myfun, Tuple{Float64})
wasm2wast("myfun.wasm") # look at the textual representation
This generates a WebAssembly file. The conversion to a binary WASM file uses LLVM's llc and lld.
WebAssembly is a new standard for running compiled code in a web browser. If Julia can generate WebAssembly, it opens up many opportunities to embed Julia "apps" in web interfaces. Julia is well positioned here because Julia can already compile efficient LLVM bitcode.
I have explored several approaches to generate WebAssembly. The two most promising approaches to generate WebAssembly are outlined as follows.
  1. CUDAnative approach – That's the approach in the master branch of this repository. It uses code from the CUDAnative package to produce LLVM bitcode on the fly. It works great for simple code (type stable code with no use of libjulia or other C functions). Math code that uses immutable structs and/or StaticArrays works well with this approach. The main downside is that it is so limited–-no arrays, no strings, no IO, etc. This approach could be extended to substitute out libjulia-type functions with equivalents that work in JavaScript/WebAssembly. For example, this crude example shows a custom array type that could work with WebAssembly. The main steps necessary to extend this approach are: (1) write a package to create WebAssembly-friendly versions of basic Julia types and operations (Dicts, Strings, Arrays, and printing) and (2) use the Cassette package or another approach to replace standard Julia dispatches involving these basic types with the WebAssembly-friendly versions.
  2. CodeGen.jl approach – The codegen-jl branch of this repository uses this approach. The CodeGen package uses the LLVM package to directly generate bitcode based on code_typed Julia code. This can use libjulia functions (also compiled to LLVM bitcode), so a wider range of Julia code may work. Some decently complex code runs, including some simple array creation and manipulation. But, there are still many gaps that need to be filled in here to be able to run Julia code in general. The main work with this approach is in upgrading the CodeGen package to support more Julia code. This method offers the most control over code generation and may allow the widest Julia code coverage (including code that links to C and Fortran libraries). It may also be wise to swap out libjulia methods with WebAssembly-focused versions. This could limit code size and allow easier integration.
Both of these approaches are on hold (as of March 2018) pending updates to Julia v0.7/1.0. These has been a lot of change in Julia related to the internal representation (IR) and how to access code generation. LLVM may also be upgraded as part of the transition to v1.0.
Right now, this repo only works with Julia v0.7dev master.
About
[WIP] Export Julia functions to WebAssembly and JavaScript
Resources
Readme
License
Activity
Stars
23 stars
Watchers
8 watching
Forks
3 forks
Report repository
Releases
Packages
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('^' + ".*" + '
GitHub - tshort/ExportWebAssembly.jl: [WIP] Export Julia functions to WebAssembly and JavaScript · GitHub
Skip to content
BranchesTags
Repository files navigation
ExportWebAssembly
This package is very experimental.
The main purpose of this package is to generate WebAssembly and/or JavaScript from Julia code.
Example:
myfun(x) =sum((x, x, 1.0))
irgen(myfun, Tuple{Float64})) # look at the LLVM IR generatedwrite_wasm("myfun.wasm", myfun, Tuple{Float64})
wasm2wast("myfun.wasm") # look at the textual representation
This generates a WebAssembly file. The conversion to a binary WASM file uses LLVM's llc and lld.
WebAssembly is a new standard for running compiled code in a web browser. If Julia can generate WebAssembly, it opens up many opportunities to embed Julia "apps" in web interfaces. Julia is well positioned here because Julia can already compile efficient LLVM bitcode.
I have explored several approaches to generate WebAssembly. The two most promising approaches to generate WebAssembly are outlined as follows.
  1. CUDAnative approach – That's the approach in the master branch of this repository. It uses code from the CUDAnative package to produce LLVM bitcode on the fly. It works great for simple code (type stable code with no use of libjulia or other C functions). Math code that uses immutable structs and/or StaticArrays works well with this approach. The main downside is that it is so limited–-no arrays, no strings, no IO, etc. This approach could be extended to substitute out libjulia-type functions with equivalents that work in JavaScript/WebAssembly. For example, this crude example shows a custom array type that could work with WebAssembly. The main steps necessary to extend this approach are: (1) write a package to create WebAssembly-friendly versions of basic Julia types and operations (Dicts, Strings, Arrays, and printing) and (2) use the Cassette package or another approach to replace standard Julia dispatches involving these basic types with the WebAssembly-friendly versions.
  2. CodeGen.jl approach – The codegen-jl branch of this repository uses this approach. The CodeGen package uses the LLVM package to directly generate bitcode based on code_typed Julia code. This can use libjulia functions (also compiled to LLVM bitcode), so a wider range of Julia code may work. Some decently complex code runs, including some simple array creation and manipulation. But, there are still many gaps that need to be filled in here to be able to run Julia code in general. The main work with this approach is in upgrading the CodeGen package to support more Julia code. This method offers the most control over code generation and may allow the widest Julia code coverage (including code that links to C and Fortran libraries). It may also be wise to swap out libjulia methods with WebAssembly-focused versions. This could limit code size and allow easier integration.
Both of these approaches are on hold (as of March 2018) pending updates to Julia v0.7/1.0. These has been a lot of change in Julia related to the internal representation (IR) and how to access code generation. LLVM may also be upgraded as part of the transition to v1.0.
Right now, this repo only works with Julia v0.7dev master.
About
[WIP] Export Julia functions to WebAssembly and JavaScript
Resources
Readme
License
Activity
Stars
23 stars
Watchers
8 watching
Forks
3 forks
Report repository
Releases
Packages
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('^' + ".*" + '
GitHub - tshort/ExportWebAssembly.jl: [WIP] Export Julia functions to WebAssembly and JavaScript · GitHub
Skip to content
BranchesTags
Repository files navigation
ExportWebAssembly
This package is very experimental.
The main purpose of this package is to generate WebAssembly and/or JavaScript from Julia code.
Example:
myfun(x) =sum((x, x, 1.0))
irgen(myfun, Tuple{Float64})) # look at the LLVM IR generatedwrite_wasm("myfun.wasm", myfun, Tuple{Float64})
wasm2wast("myfun.wasm") # look at the textual representation
This generates a WebAssembly file. The conversion to a binary WASM file uses LLVM's llc and lld.
WebAssembly is a new standard for running compiled code in a web browser. If Julia can generate WebAssembly, it opens up many opportunities to embed Julia "apps" in web interfaces. Julia is well positioned here because Julia can already compile efficient LLVM bitcode.
I have explored several approaches to generate WebAssembly. The two most promising approaches to generate WebAssembly are outlined as follows.
  1. CUDAnative approach – That's the approach in the master branch of this repository. It uses code from the CUDAnative package to produce LLVM bitcode on the fly. It works great for simple code (type stable code with no use of libjulia or other C functions). Math code that uses immutable structs and/or StaticArrays works well with this approach. The main downside is that it is so limited–-no arrays, no strings, no IO, etc. This approach could be extended to substitute out libjulia-type functions with equivalents that work in JavaScript/WebAssembly. For example, this crude example shows a custom array type that could work with WebAssembly. The main steps necessary to extend this approach are: (1) write a package to create WebAssembly-friendly versions of basic Julia types and operations (Dicts, Strings, Arrays, and printing) and (2) use the Cassette package or another approach to replace standard Julia dispatches involving these basic types with the WebAssembly-friendly versions.
  2. CodeGen.jl approach – The codegen-jl branch of this repository uses this approach. The CodeGen package uses the LLVM package to directly generate bitcode based on code_typed Julia code. This can use libjulia functions (also compiled to LLVM bitcode), so a wider range of Julia code may work. Some decently complex code runs, including some simple array creation and manipulation. But, there are still many gaps that need to be filled in here to be able to run Julia code in general. The main work with this approach is in upgrading the CodeGen package to support more Julia code. This method offers the most control over code generation and may allow the widest Julia code coverage (including code that links to C and Fortran libraries). It may also be wise to swap out libjulia methods with WebAssembly-focused versions. This could limit code size and allow easier integration.
Both of these approaches are on hold (as of March 2018) pending updates to Julia v0.7/1.0. These has been a lot of change in Julia related to the internal representation (IR) and how to access code generation. LLVM may also be upgraded as part of the transition to v1.0.
Right now, this repo only works with Julia v0.7dev master.
About
[WIP] Export Julia functions to WebAssembly and JavaScript
Resources
Readme
License
Activity
Stars
23 stars
Watchers
8 watching
Forks
3 forks
Report repository
Releases
Packages
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" + '
GitHub - tshort/ExportWebAssembly.jl: [WIP] Export Julia functions to WebAssembly and JavaScript · GitHub
Skip to content
BranchesTags
Repository files navigation
ExportWebAssembly
This package is very experimental.
The main purpose of this package is to generate WebAssembly and/or JavaScript from Julia code.
Example:
myfun(x) =sum((x, x, 1.0))
irgen(myfun, Tuple{Float64})) # look at the LLVM IR generatedwrite_wasm("myfun.wasm", myfun, Tuple{Float64})
wasm2wast("myfun.wasm") # look at the textual representation
This generates a WebAssembly file. The conversion to a binary WASM file uses LLVM's llc and lld.
WebAssembly is a new standard for running compiled code in a web browser. If Julia can generate WebAssembly, it opens up many opportunities to embed Julia "apps" in web interfaces. Julia is well positioned here because Julia can already compile efficient LLVM bitcode.
I have explored several approaches to generate WebAssembly. The two most promising approaches to generate WebAssembly are outlined as follows.
  1. CUDAnative approach – That's the approach in the master branch of this repository. It uses code from the CUDAnative package to produce LLVM bitcode on the fly. It works great for simple code (type stable code with no use of libjulia or other C functions). Math code that uses immutable structs and/or StaticArrays works well with this approach. The main downside is that it is so limited–-no arrays, no strings, no IO, etc. This approach could be extended to substitute out libjulia-type functions with equivalents that work in JavaScript/WebAssembly. For example, this crude example shows a custom array type that could work with WebAssembly. The main steps necessary to extend this approach are: (1) write a package to create WebAssembly-friendly versions of basic Julia types and operations (Dicts, Strings, Arrays, and printing) and (2) use the Cassette package or another approach to replace standard Julia dispatches involving these basic types with the WebAssembly-friendly versions.
  2. CodeGen.jl approach – The codegen-jl branch of this repository uses this approach. The CodeGen package uses the LLVM package to directly generate bitcode based on code_typed Julia code. This can use libjulia functions (also compiled to LLVM bitcode), so a wider range of Julia code may work. Some decently complex code runs, including some simple array creation and manipulation. But, there are still many gaps that need to be filled in here to be able to run Julia code in general. The main work with this approach is in upgrading the CodeGen package to support more Julia code. This method offers the most control over code generation and may allow the widest Julia code coverage (including code that links to C and Fortran libraries). It may also be wise to swap out libjulia methods with WebAssembly-focused versions. This could limit code size and allow easier integration.
Both of these approaches are on hold (as of March 2018) pending updates to Julia v0.7/1.0. These has been a lot of change in Julia related to the internal representation (IR) and how to access code generation. LLVM may also be upgraded as part of the transition to v1.0.
Right now, this repo only works with Julia v0.7dev master.
About
[WIP] Export Julia functions to WebAssembly and JavaScript
Resources
Readme
License
Activity
Stars
23 stars
Watchers
8 watching
Forks
3 forks
Report repository
Releases
Packages
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('^' + ".*" + '
GitHub - tshort/ExportWebAssembly.jl: [WIP] Export Julia functions to WebAssembly and JavaScript · GitHub
Skip to content
BranchesTags
Repository files navigation
ExportWebAssembly
This package is very experimental.
The main purpose of this package is to generate WebAssembly and/or JavaScript from Julia code.
Example:
myfun(x) =sum((x, x, 1.0))
irgen(myfun, Tuple{Float64})) # look at the LLVM IR generatedwrite_wasm("myfun.wasm", myfun, Tuple{Float64})
wasm2wast("myfun.wasm") # look at the textual representation
This generates a WebAssembly file. The conversion to a binary WASM file uses LLVM's llc and lld.
WebAssembly is a new standard for running compiled code in a web browser. If Julia can generate WebAssembly, it opens up many opportunities to embed Julia "apps" in web interfaces. Julia is well positioned here because Julia can already compile efficient LLVM bitcode.
I have explored several approaches to generate WebAssembly. The two most promising approaches to generate WebAssembly are outlined as follows.
  1. CUDAnative approach – That's the approach in the master branch of this repository. It uses code from the CUDAnative package to produce LLVM bitcode on the fly. It works great for simple code (type stable code with no use of libjulia or other C functions). Math code that uses immutable structs and/or StaticArrays works well with this approach. The main downside is that it is so limited–-no arrays, no strings, no IO, etc. This approach could be extended to substitute out libjulia-type functions with equivalents that work in JavaScript/WebAssembly. For example, this crude example shows a custom array type that could work with WebAssembly. The main steps necessary to extend this approach are: (1) write a package to create WebAssembly-friendly versions of basic Julia types and operations (Dicts, Strings, Arrays, and printing) and (2) use the Cassette package or another approach to replace standard Julia dispatches involving these basic types with the WebAssembly-friendly versions.
  2. CodeGen.jl approach – The codegen-jl branch of this repository uses this approach. The CodeGen package uses the LLVM package to directly generate bitcode based on code_typed Julia code. This can use libjulia functions (also compiled to LLVM bitcode), so a wider range of Julia code may work. Some decently complex code runs, including some simple array creation and manipulation. But, there are still many gaps that need to be filled in here to be able to run Julia code in general. The main work with this approach is in upgrading the CodeGen package to support more Julia code. This method offers the most control over code generation and may allow the widest Julia code coverage (including code that links to C and Fortran libraries). It may also be wise to swap out libjulia methods with WebAssembly-focused versions. This could limit code size and allow easier integration.
Both of these approaches are on hold (as of March 2018) pending updates to Julia v0.7/1.0. These has been a lot of change in Julia related to the internal representation (IR) and how to access code generation. LLVM may also be upgraded as part of the transition to v1.0.
Right now, this repo only works with Julia v0.7dev master.
About
[WIP] Export Julia functions to WebAssembly and JavaScript
Resources
Readme
License
Activity
Stars
23 stars
Watchers
8 watching
Forks
3 forks
Report repository
Releases
Packages
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('^' + ".*" + '
GitHub - tshort/ExportWebAssembly.jl: [WIP] Export Julia functions to WebAssembly and JavaScript · GitHub
Skip to content
BranchesTags
Repository files navigation
ExportWebAssembly
This package is very experimental.
The main purpose of this package is to generate WebAssembly and/or JavaScript from Julia code.
Example:
myfun(x) =sum((x, x, 1.0))
irgen(myfun, Tuple{Float64})) # look at the LLVM IR generatedwrite_wasm("myfun.wasm", myfun, Tuple{Float64})
wasm2wast("myfun.wasm") # look at the textual representation
This generates a WebAssembly file. The conversion to a binary WASM file uses LLVM's llc and lld.
WebAssembly is a new standard for running compiled code in a web browser. If Julia can generate WebAssembly, it opens up many opportunities to embed Julia "apps" in web interfaces. Julia is well positioned here because Julia can already compile efficient LLVM bitcode.
I have explored several approaches to generate WebAssembly. The two most promising approaches to generate WebAssembly are outlined as follows.
  1. CUDAnative approach – That's the approach in the master branch of this repository. It uses code from the CUDAnative package to produce LLVM bitcode on the fly. It works great for simple code (type stable code with no use of libjulia or other C functions). Math code that uses immutable structs and/or StaticArrays works well with this approach. The main downside is that it is so limited–-no arrays, no strings, no IO, etc. This approach could be extended to substitute out libjulia-type functions with equivalents that work in JavaScript/WebAssembly. For example, this crude example shows a custom array type that could work with WebAssembly. The main steps necessary to extend this approach are: (1) write a package to create WebAssembly-friendly versions of basic Julia types and operations (Dicts, Strings, Arrays, and printing) and (2) use the Cassette package or another approach to replace standard Julia dispatches involving these basic types with the WebAssembly-friendly versions.
  2. CodeGen.jl approach – The codegen-jl branch of this repository uses this approach. The CodeGen package uses the LLVM package to directly generate bitcode based on code_typed Julia code. This can use libjulia functions (also compiled to LLVM bitcode), so a wider range of Julia code may work. Some decently complex code runs, including some simple array creation and manipulation. But, there are still many gaps that need to be filled in here to be able to run Julia code in general. The main work with this approach is in upgrading the CodeGen package to support more Julia code. This method offers the most control over code generation and may allow the widest Julia code coverage (including code that links to C and Fortran libraries). It may also be wise to swap out libjulia methods with WebAssembly-focused versions. This could limit code size and allow easier integration.
Both of these approaches are on hold (as of March 2018) pending updates to Julia v0.7/1.0. These has been a lot of change in Julia related to the internal representation (IR) and how to access code generation. LLVM may also be upgraded as part of the transition to v1.0.
Right now, this repo only works with Julia v0.7dev master.
About
[WIP] Export Julia functions to WebAssembly and JavaScript
Resources
Readme
License
Activity
Stars
23 stars
Watchers
8 watching
Forks
3 forks
Report repository
Releases
Packages
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); }
})();
})();
GitHub - tshort/ExportWebAssembly.jl: [WIP] Export Julia functions to WebAssembly and JavaScript · GitHub
Skip to content
BranchesTags
Repository files navigation
ExportWebAssembly
This package is very experimental.
The main purpose of this package is to generate WebAssembly and/or JavaScript from Julia code.
Example:
myfun(x) =sum((x, x, 1.0))
irgen(myfun, Tuple{Float64})) # look at the LLVM IR generatedwrite_wasm("myfun.wasm", myfun, Tuple{Float64})
wasm2wast("myfun.wasm") # look at the textual representation
This generates a WebAssembly file. The conversion to a binary WASM file uses LLVM's llc and lld.
WebAssembly is a new standard for running compiled code in a web browser. If Julia can generate WebAssembly, it opens up many opportunities to embed Julia "apps" in web interfaces. Julia is well positioned here because Julia can already compile efficient LLVM bitcode.
I have explored several approaches to generate WebAssembly. The two most promising approaches to generate WebAssembly are outlined as follows.
  1. CUDAnative approach – That's the approach in the master branch of this repository. It uses code from the CUDAnative package to produce LLVM bitcode on the fly. It works great for simple code (type stable code with no use of libjulia or other C functions). Math code that uses immutable structs and/or StaticArrays works well with this approach. The main downside is that it is so limited–-no arrays, no strings, no IO, etc. This approach could be extended to substitute out libjulia-type functions with equivalents that work in JavaScript/WebAssembly. For example, this crude example shows a custom array type that could work with WebAssembly. The main steps necessary to extend this approach are: (1) write a package to create WebAssembly-friendly versions of basic Julia types and operations (Dicts, Strings, Arrays, and printing) and (2) use the Cassette package or another approach to replace standard Julia dispatches involving these basic types with the WebAssembly-friendly versions.
  2. CodeGen.jl approach – The codegen-jl branch of this repository uses this approach. The CodeGen package uses the LLVM package to directly generate bitcode based on code_typed Julia code. This can use libjulia functions (also compiled to LLVM bitcode), so a wider range of Julia code may work. Some decently complex code runs, including some simple array creation and manipulation. But, there are still many gaps that need to be filled in here to be able to run Julia code in general. The main work with this approach is in upgrading the CodeGen package to support more Julia code. This method offers the most control over code generation and may allow the widest Julia code coverage (including code that links to C and Fortran libraries). It may also be wise to swap out libjulia methods with WebAssembly-focused versions. This could limit code size and allow easier integration.
Both of these approaches are on hold (as of March 2018) pending updates to Julia v0.7/1.0. These has been a lot of change in Julia related to the internal representation (IR) and how to access code generation. LLVM may also be upgraded as part of the transition to v1.0.
Right now, this repo only works with Julia v0.7dev master.
About
[WIP] Export Julia functions to WebAssembly and JavaScript
Resources
Readme
License
Activity
Stars
23 stars
Watchers
8 watching
Forks
3 forks
Report repository
Releases
Packages
Contributors
Languages