Skip to content
BranchesTags

Repository files navigation

cuik-molmaker

cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).

cuik-molmaker is built as a hybrid package, leveraging both C++ and Python to deliver high performance and ease of use. The core featurization logic is implemented in C++ for maximum speed and efficiency, while the Python interface provides a user-friendly API that integrates seamlessly with modern GNN training and inference workflows. This design combines the computational power of C++ with the flexibility and accessibility of Python, making cuik-molmaker both fast and intuitive for researchers and developers. As cuik-molmaker interfaces with the C++ API of rdkit, the produced features are expected to be identical to those produced by rdkit.

Quick start

Conda installation

conda install -c conda-forge cuik_molmaker

Pip installation

python -m pip install cuik-molmaker-pin==<RDKit version>

Pip installation from NVIDIA PyPI

python -m pip install cuik-molmaker --extra-index-url https://pypi.nvidia.com/rdkit-2026.03.4/

For more information on the available versions of cuik-molmaker compatible with different versions of rdkit, refer to the COMPATIBILITY.md.

Usage: Computing atom and bond features

importcuik_molmakerimportnumpyasnp# List all available atom onehot featuresprint(cuik_molmaker.list_all_atom_onehot_features())
# Compute atom (atomic number, number of hydrogen, chirality) and bond (bond type) features for acetic acidacetic_acid_smiles="CC(=O)O"# Get atom onehot feature names as NumPy arrayatom_onehot_feature_array=cuik_molmaker.atom_onehot_feature_names_to_array(['atomic-number', 'num-hydrogens', 'chirality'])
# Get bond feature names as NumPy arraybond_feature_array=cuik_molmaker.bond_feature_names_to_array(['bond-type-onehot'])
# Set parameters for featurizationexplicit_h, offset_carbon, duplicate_edges, add_self_loop=False, False, True, False# Featurizeall_features=cuik_molmaker.mol_featurizer(acetic_acid_smiles, atom_onehot_feature_array, np.array([]), bond_feature_array, explicit_h, offset_carbon, duplicate_edges, add_self_loop)
# This returns a list of NumPy arrays.# First index contains atom featuresprint(all_features[0].shape)
# Second index contains bond featuresprint(all_features[1].shape)
# Third index contains edge indices in COO formatprint(all_features[2].shape)

Usage: Computing molecular descriptors

fromcuik_molmaker.mol_featuresimportMoleculeFeaturizerfeaturizer=MoleculeFeaturizer(molecular_descriptor_type="rdkit2D", rdkit2D_normalization_type="fast")
smiles_list= ["CC(=O)OC1=CC=CC=C1C(=O)O", # aspirin"CN(C)CCOC(C1=CC=CC=C1)C1=CC=CC=C1", # diphenhydramine
]
rdkit2D_descriptors=featurizer.featurize(smiles_list)
# Print the shape of the descriptorsprint(rdkit2D_descriptors.shape)

Source of acceleration

The hybrid C++/Python design of cuik-molmaker allows for the core featurization logic to be implemented in C++ and reduces the python overhead. Another source of acceleration is the creation of features for the entire minibatch of SMILES at once, which saves the overhead of creating memory allocation and concatenation.

Additional Documentation

FileDescription
USAGE.mdExamples and instructions for using cuik-molmaker to featurize molecules including batching.
FEATURES.mdDetailed list and explanation of all atom and bond features available for featurization.
BUILD.mdStep-by-step instructions for building cuik-molmaker from source, including prerequisites and troubleshooting.
TESTING.mdGuidelines and commands for running the test suite to verify installation and functionality.
COMPATIBILITY.mdPublished package builds by release channel, OS, and Python version.

Hardware Requirements

cuik-molmaker is designed to run on any CPU-based system.

Adoption

cuik-molmaker has currently been integrated into the following projects:

  • Chemprop: cuik-molmaker is available as a featurization method in Chemprop. It can be enabled by setting --use-cuikmolmaker-featurization flag in the command line with all use cases: training, prediction, fingerprinting, and hyperparameter optimization.
  • KERMT: cuik-molmaker is available for featurizing atoms, bonds, and molecules in KERMT. Atom and bond featurization can be enabled by setting --use_cuikmolmaker_featurization flag and molecule featurization can be enabled by setting --features_generator=rdkit_2d_normalized_cuik_molmaker.

About

cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).

Resources

Readme

Contributing

Contributing
Activity
Custom properties

Stars

36 stars

Watchers

3 watching

Forks

5 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 - NVIDIA-BioNeMo/cuik-molmaker: cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs). · GitHub
Skip to content
BranchesTags
Repository files navigation
cuik-molmaker
cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).
cuik-molmaker is built as a hybrid package, leveraging both C++ and Python to deliver high performance and ease of use. The core featurization logic is implemented in C++ for maximum speed and efficiency, while the Python interface provides a user-friendly API that integrates seamlessly with modern GNN training and inference workflows. This design combines the computational power of C++ with the flexibility and accessibility of Python, making cuik-molmaker both fast and intuitive for researchers and developers. As cuik-molmaker interfaces with the C++ API of rdkit, the produced features are expected to be identical to those produced by rdkit.
Quick start
Conda installation
conda install -c conda-forge cuik_molmaker
Pip installation
python -m pip install cuik-molmaker-pin==<RDKit version>
Pip installation from NVIDIA PyPI
python -m pip install cuik-molmaker --extra-index-url https://pypi.nvidia.com/rdkit-2026.03.4/
For more information on the available versions of cuik-molmaker compatible with different versions of rdkit, refer to the COMPATIBILITY.md.
Usage: Computing atom and bond features
importcuik_molmakerimportnumpyasnp# List all available atom onehot featuresprint(cuik_molmaker.list_all_atom_onehot_features())
# Compute atom (atomic number, number of hydrogen, chirality) and bond (bond type) features for acetic acidacetic_acid_smiles="CC(=O)O"# Get atom onehot feature names as NumPy arrayatom_onehot_feature_array=cuik_molmaker.atom_onehot_feature_names_to_array(['atomic-number', 'num-hydrogens', 'chirality'])
# Get bond feature names as NumPy arraybond_feature_array=cuik_molmaker.bond_feature_names_to_array(['bond-type-onehot'])
# Set parameters for featurizationexplicit_h, offset_carbon, duplicate_edges, add_self_loop=False, False, True, False# Featurizeall_features=cuik_molmaker.mol_featurizer(acetic_acid_smiles, atom_onehot_feature_array, np.array([]), bond_feature_array, explicit_h, offset_carbon, duplicate_edges, add_self_loop)
# This returns a list of NumPy arrays.# First index contains atom featuresprint(all_features[0].shape)
# Second index contains bond featuresprint(all_features[1].shape)
# Third index contains edge indices in COO formatprint(all_features[2].shape)
Usage: Computing molecular descriptors
fromcuik_molmaker.mol_featuresimportMoleculeFeaturizerfeaturizer=MoleculeFeaturizer(molecular_descriptor_type="rdkit2D", rdkit2D_normalization_type="fast")
smiles_list= ["CC(=O)OC1=CC=CC=C1C(=O)O", # aspirin"CN(C)CCOC(C1=CC=CC=C1)C1=CC=CC=C1", # diphenhydramine
]
rdkit2D_descriptors=featurizer.featurize(smiles_list)
# Print the shape of the descriptorsprint(rdkit2D_descriptors.shape)
Source of acceleration
The hybrid C++/Python design of cuik-molmaker allows for the core featurization logic to be implemented in C++ and reduces the python overhead. Another source of acceleration is the creation of features for the entire minibatch of SMILES at once, which saves the overhead of creating memory allocation and concatenation.
Additional Documentation
FileDescription
USAGE.mdExamples and instructions for using cuik-molmaker to featurize molecules including batching.
FEATURES.mdDetailed list and explanation of all atom and bond features available for featurization.
BUILD.mdStep-by-step instructions for building cuik-molmaker from source, including prerequisites and troubleshooting.
TESTING.mdGuidelines and commands for running the test suite to verify installation and functionality.
COMPATIBILITY.mdPublished package builds by release channel, OS, and Python version.
Hardware Requirements
cuik-molmaker is designed to run on any CPU-based system.
Adoption
cuik-molmaker has currently been integrated into the following projects:
  • Chemprop: cuik-molmaker is available as a featurization method in Chemprop. It can be enabled by setting --use-cuikmolmaker-featurization flag in the command line with all use cases: training, prediction, fingerprinting, and hyperparameter optimization.
  • KERMT: cuik-molmaker is available for featurizing atoms, bonds, and molecules in KERMT. Atom and bond featurization can be enabled by setting --use_cuikmolmaker_featurization flag and molecule featurization can be enabled by setting --features_generator=rdkit_2d_normalized_cuik_molmaker.
About
cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).
Resources
Readme
Contributing
Contributing
Activity
Custom properties
Stars
36 stars
Watchers
3 watching
Forks
5 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 - NVIDIA-BioNeMo/cuik-molmaker: cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs). · GitHub
Skip to content
BranchesTags
Repository files navigation
cuik-molmaker
cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).
cuik-molmaker is built as a hybrid package, leveraging both C++ and Python to deliver high performance and ease of use. The core featurization logic is implemented in C++ for maximum speed and efficiency, while the Python interface provides a user-friendly API that integrates seamlessly with modern GNN training and inference workflows. This design combines the computational power of C++ with the flexibility and accessibility of Python, making cuik-molmaker both fast and intuitive for researchers and developers. As cuik-molmaker interfaces with the C++ API of rdkit, the produced features are expected to be identical to those produced by rdkit.
Quick start
Conda installation
conda install -c conda-forge cuik_molmaker
Pip installation
python -m pip install cuik-molmaker-pin==<RDKit version>
Pip installation from NVIDIA PyPI
python -m pip install cuik-molmaker --extra-index-url https://pypi.nvidia.com/rdkit-2026.03.4/
For more information on the available versions of cuik-molmaker compatible with different versions of rdkit, refer to the COMPATIBILITY.md.
Usage: Computing atom and bond features
importcuik_molmakerimportnumpyasnp# List all available atom onehot featuresprint(cuik_molmaker.list_all_atom_onehot_features())
# Compute atom (atomic number, number of hydrogen, chirality) and bond (bond type) features for acetic acidacetic_acid_smiles="CC(=O)O"# Get atom onehot feature names as NumPy arrayatom_onehot_feature_array=cuik_molmaker.atom_onehot_feature_names_to_array(['atomic-number', 'num-hydrogens', 'chirality'])
# Get bond feature names as NumPy arraybond_feature_array=cuik_molmaker.bond_feature_names_to_array(['bond-type-onehot'])
# Set parameters for featurizationexplicit_h, offset_carbon, duplicate_edges, add_self_loop=False, False, True, False# Featurizeall_features=cuik_molmaker.mol_featurizer(acetic_acid_smiles, atom_onehot_feature_array, np.array([]), bond_feature_array, explicit_h, offset_carbon, duplicate_edges, add_self_loop)
# This returns a list of NumPy arrays.# First index contains atom featuresprint(all_features[0].shape)
# Second index contains bond featuresprint(all_features[1].shape)
# Third index contains edge indices in COO formatprint(all_features[2].shape)
Usage: Computing molecular descriptors
fromcuik_molmaker.mol_featuresimportMoleculeFeaturizerfeaturizer=MoleculeFeaturizer(molecular_descriptor_type="rdkit2D", rdkit2D_normalization_type="fast")
smiles_list= ["CC(=O)OC1=CC=CC=C1C(=O)O", # aspirin"CN(C)CCOC(C1=CC=CC=C1)C1=CC=CC=C1", # diphenhydramine
]
rdkit2D_descriptors=featurizer.featurize(smiles_list)
# Print the shape of the descriptorsprint(rdkit2D_descriptors.shape)
Source of acceleration
The hybrid C++/Python design of cuik-molmaker allows for the core featurization logic to be implemented in C++ and reduces the python overhead. Another source of acceleration is the creation of features for the entire minibatch of SMILES at once, which saves the overhead of creating memory allocation and concatenation.
Additional Documentation
FileDescription
USAGE.mdExamples and instructions for using cuik-molmaker to featurize molecules including batching.
FEATURES.mdDetailed list and explanation of all atom and bond features available for featurization.
BUILD.mdStep-by-step instructions for building cuik-molmaker from source, including prerequisites and troubleshooting.
TESTING.mdGuidelines and commands for running the test suite to verify installation and functionality.
COMPATIBILITY.mdPublished package builds by release channel, OS, and Python version.
Hardware Requirements
cuik-molmaker is designed to run on any CPU-based system.
Adoption
cuik-molmaker has currently been integrated into the following projects:
  • Chemprop: cuik-molmaker is available as a featurization method in Chemprop. It can be enabled by setting --use-cuikmolmaker-featurization flag in the command line with all use cases: training, prediction, fingerprinting, and hyperparameter optimization.
  • KERMT: cuik-molmaker is available for featurizing atoms, bonds, and molecules in KERMT. Atom and bond featurization can be enabled by setting --use_cuikmolmaker_featurization flag and molecule featurization can be enabled by setting --features_generator=rdkit_2d_normalized_cuik_molmaker.
About
cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).
Resources
Readme
Contributing
Contributing
Activity
Custom properties
Stars
36 stars
Watchers
3 watching
Forks
5 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 - NVIDIA-BioNeMo/cuik-molmaker: cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs). · GitHub
Skip to content
BranchesTags
Repository files navigation
cuik-molmaker
cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).
cuik-molmaker is built as a hybrid package, leveraging both C++ and Python to deliver high performance and ease of use. The core featurization logic is implemented in C++ for maximum speed and efficiency, while the Python interface provides a user-friendly API that integrates seamlessly with modern GNN training and inference workflows. This design combines the computational power of C++ with the flexibility and accessibility of Python, making cuik-molmaker both fast and intuitive for researchers and developers. As cuik-molmaker interfaces with the C++ API of rdkit, the produced features are expected to be identical to those produced by rdkit.
Quick start
Conda installation
conda install -c conda-forge cuik_molmaker
Pip installation
python -m pip install cuik-molmaker-pin==<RDKit version>
Pip installation from NVIDIA PyPI
python -m pip install cuik-molmaker --extra-index-url https://pypi.nvidia.com/rdkit-2026.03.4/
For more information on the available versions of cuik-molmaker compatible with different versions of rdkit, refer to the COMPATIBILITY.md.
Usage: Computing atom and bond features
importcuik_molmakerimportnumpyasnp# List all available atom onehot featuresprint(cuik_molmaker.list_all_atom_onehot_features())
# Compute atom (atomic number, number of hydrogen, chirality) and bond (bond type) features for acetic acidacetic_acid_smiles="CC(=O)O"# Get atom onehot feature names as NumPy arrayatom_onehot_feature_array=cuik_molmaker.atom_onehot_feature_names_to_array(['atomic-number', 'num-hydrogens', 'chirality'])
# Get bond feature names as NumPy arraybond_feature_array=cuik_molmaker.bond_feature_names_to_array(['bond-type-onehot'])
# Set parameters for featurizationexplicit_h, offset_carbon, duplicate_edges, add_self_loop=False, False, True, False# Featurizeall_features=cuik_molmaker.mol_featurizer(acetic_acid_smiles, atom_onehot_feature_array, np.array([]), bond_feature_array, explicit_h, offset_carbon, duplicate_edges, add_self_loop)
# This returns a list of NumPy arrays.# First index contains atom featuresprint(all_features[0].shape)
# Second index contains bond featuresprint(all_features[1].shape)
# Third index contains edge indices in COO formatprint(all_features[2].shape)
Usage: Computing molecular descriptors
fromcuik_molmaker.mol_featuresimportMoleculeFeaturizerfeaturizer=MoleculeFeaturizer(molecular_descriptor_type="rdkit2D", rdkit2D_normalization_type="fast")
smiles_list= ["CC(=O)OC1=CC=CC=C1C(=O)O", # aspirin"CN(C)CCOC(C1=CC=CC=C1)C1=CC=CC=C1", # diphenhydramine
]
rdkit2D_descriptors=featurizer.featurize(smiles_list)
# Print the shape of the descriptorsprint(rdkit2D_descriptors.shape)
Source of acceleration
The hybrid C++/Python design of cuik-molmaker allows for the core featurization logic to be implemented in C++ and reduces the python overhead. Another source of acceleration is the creation of features for the entire minibatch of SMILES at once, which saves the overhead of creating memory allocation and concatenation.
Additional Documentation
FileDescription
USAGE.mdExamples and instructions for using cuik-molmaker to featurize molecules including batching.
FEATURES.mdDetailed list and explanation of all atom and bond features available for featurization.
BUILD.mdStep-by-step instructions for building cuik-molmaker from source, including prerequisites and troubleshooting.
TESTING.mdGuidelines and commands for running the test suite to verify installation and functionality.
COMPATIBILITY.mdPublished package builds by release channel, OS, and Python version.
Hardware Requirements
cuik-molmaker is designed to run on any CPU-based system.
Adoption
cuik-molmaker has currently been integrated into the following projects:
  • Chemprop: cuik-molmaker is available as a featurization method in Chemprop. It can be enabled by setting --use-cuikmolmaker-featurization flag in the command line with all use cases: training, prediction, fingerprinting, and hyperparameter optimization.
  • KERMT: cuik-molmaker is available for featurizing atoms, bonds, and molecules in KERMT. Atom and bond featurization can be enabled by setting --use_cuikmolmaker_featurization flag and molecule featurization can be enabled by setting --features_generator=rdkit_2d_normalized_cuik_molmaker.
About
cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).
Resources
Readme
Contributing
Contributing
Activity
Custom properties
Stars
36 stars
Watchers
3 watching
Forks
5 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 - NVIDIA-BioNeMo/cuik-molmaker: cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs). · GitHub
Skip to content
BranchesTags
Repository files navigation
cuik-molmaker
cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).
cuik-molmaker is built as a hybrid package, leveraging both C++ and Python to deliver high performance and ease of use. The core featurization logic is implemented in C++ for maximum speed and efficiency, while the Python interface provides a user-friendly API that integrates seamlessly with modern GNN training and inference workflows. This design combines the computational power of C++ with the flexibility and accessibility of Python, making cuik-molmaker both fast and intuitive for researchers and developers. As cuik-molmaker interfaces with the C++ API of rdkit, the produced features are expected to be identical to those produced by rdkit.
Quick start
Conda installation
conda install -c conda-forge cuik_molmaker
Pip installation
python -m pip install cuik-molmaker-pin==<RDKit version>
Pip installation from NVIDIA PyPI
python -m pip install cuik-molmaker --extra-index-url https://pypi.nvidia.com/rdkit-2026.03.4/
For more information on the available versions of cuik-molmaker compatible with different versions of rdkit, refer to the COMPATIBILITY.md.
Usage: Computing atom and bond features
importcuik_molmakerimportnumpyasnp# List all available atom onehot featuresprint(cuik_molmaker.list_all_atom_onehot_features())
# Compute atom (atomic number, number of hydrogen, chirality) and bond (bond type) features for acetic acidacetic_acid_smiles="CC(=O)O"# Get atom onehot feature names as NumPy arrayatom_onehot_feature_array=cuik_molmaker.atom_onehot_feature_names_to_array(['atomic-number', 'num-hydrogens', 'chirality'])
# Get bond feature names as NumPy arraybond_feature_array=cuik_molmaker.bond_feature_names_to_array(['bond-type-onehot'])
# Set parameters for featurizationexplicit_h, offset_carbon, duplicate_edges, add_self_loop=False, False, True, False# Featurizeall_features=cuik_molmaker.mol_featurizer(acetic_acid_smiles, atom_onehot_feature_array, np.array([]), bond_feature_array, explicit_h, offset_carbon, duplicate_edges, add_self_loop)
# This returns a list of NumPy arrays.# First index contains atom featuresprint(all_features[0].shape)
# Second index contains bond featuresprint(all_features[1].shape)
# Third index contains edge indices in COO formatprint(all_features[2].shape)
Usage: Computing molecular descriptors
fromcuik_molmaker.mol_featuresimportMoleculeFeaturizerfeaturizer=MoleculeFeaturizer(molecular_descriptor_type="rdkit2D", rdkit2D_normalization_type="fast")
smiles_list= ["CC(=O)OC1=CC=CC=C1C(=O)O", # aspirin"CN(C)CCOC(C1=CC=CC=C1)C1=CC=CC=C1", # diphenhydramine
]
rdkit2D_descriptors=featurizer.featurize(smiles_list)
# Print the shape of the descriptorsprint(rdkit2D_descriptors.shape)
Source of acceleration
The hybrid C++/Python design of cuik-molmaker allows for the core featurization logic to be implemented in C++ and reduces the python overhead. Another source of acceleration is the creation of features for the entire minibatch of SMILES at once, which saves the overhead of creating memory allocation and concatenation.
Additional Documentation
FileDescription
USAGE.mdExamples and instructions for using cuik-molmaker to featurize molecules including batching.
FEATURES.mdDetailed list and explanation of all atom and bond features available for featurization.
BUILD.mdStep-by-step instructions for building cuik-molmaker from source, including prerequisites and troubleshooting.
TESTING.mdGuidelines and commands for running the test suite to verify installation and functionality.
COMPATIBILITY.mdPublished package builds by release channel, OS, and Python version.
Hardware Requirements
cuik-molmaker is designed to run on any CPU-based system.
Adoption
cuik-molmaker has currently been integrated into the following projects:
  • Chemprop: cuik-molmaker is available as a featurization method in Chemprop. It can be enabled by setting --use-cuikmolmaker-featurization flag in the command line with all use cases: training, prediction, fingerprinting, and hyperparameter optimization.
  • KERMT: cuik-molmaker is available for featurizing atoms, bonds, and molecules in KERMT. Atom and bond featurization can be enabled by setting --use_cuikmolmaker_featurization flag and molecule featurization can be enabled by setting --features_generator=rdkit_2d_normalized_cuik_molmaker.
About
cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).
Resources
Readme
Contributing
Contributing
Activity
Custom properties
Stars
36 stars
Watchers
3 watching
Forks
5 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 - NVIDIA-BioNeMo/cuik-molmaker: cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs). · GitHub
Skip to content
BranchesTags
Repository files navigation
cuik-molmaker
cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).
cuik-molmaker is built as a hybrid package, leveraging both C++ and Python to deliver high performance and ease of use. The core featurization logic is implemented in C++ for maximum speed and efficiency, while the Python interface provides a user-friendly API that integrates seamlessly with modern GNN training and inference workflows. This design combines the computational power of C++ with the flexibility and accessibility of Python, making cuik-molmaker both fast and intuitive for researchers and developers. As cuik-molmaker interfaces with the C++ API of rdkit, the produced features are expected to be identical to those produced by rdkit.
Quick start
Conda installation
conda install -c conda-forge cuik_molmaker
Pip installation
python -m pip install cuik-molmaker-pin==<RDKit version>
Pip installation from NVIDIA PyPI
python -m pip install cuik-molmaker --extra-index-url https://pypi.nvidia.com/rdkit-2026.03.4/
For more information on the available versions of cuik-molmaker compatible with different versions of rdkit, refer to the COMPATIBILITY.md.
Usage: Computing atom and bond features
importcuik_molmakerimportnumpyasnp# List all available atom onehot featuresprint(cuik_molmaker.list_all_atom_onehot_features())
# Compute atom (atomic number, number of hydrogen, chirality) and bond (bond type) features for acetic acidacetic_acid_smiles="CC(=O)O"# Get atom onehot feature names as NumPy arrayatom_onehot_feature_array=cuik_molmaker.atom_onehot_feature_names_to_array(['atomic-number', 'num-hydrogens', 'chirality'])
# Get bond feature names as NumPy arraybond_feature_array=cuik_molmaker.bond_feature_names_to_array(['bond-type-onehot'])
# Set parameters for featurizationexplicit_h, offset_carbon, duplicate_edges, add_self_loop=False, False, True, False# Featurizeall_features=cuik_molmaker.mol_featurizer(acetic_acid_smiles, atom_onehot_feature_array, np.array([]), bond_feature_array, explicit_h, offset_carbon, duplicate_edges, add_self_loop)
# This returns a list of NumPy arrays.# First index contains atom featuresprint(all_features[0].shape)
# Second index contains bond featuresprint(all_features[1].shape)
# Third index contains edge indices in COO formatprint(all_features[2].shape)
Usage: Computing molecular descriptors
fromcuik_molmaker.mol_featuresimportMoleculeFeaturizerfeaturizer=MoleculeFeaturizer(molecular_descriptor_type="rdkit2D", rdkit2D_normalization_type="fast")
smiles_list= ["CC(=O)OC1=CC=CC=C1C(=O)O", # aspirin"CN(C)CCOC(C1=CC=CC=C1)C1=CC=CC=C1", # diphenhydramine
]
rdkit2D_descriptors=featurizer.featurize(smiles_list)
# Print the shape of the descriptorsprint(rdkit2D_descriptors.shape)
Source of acceleration
The hybrid C++/Python design of cuik-molmaker allows for the core featurization logic to be implemented in C++ and reduces the python overhead. Another source of acceleration is the creation of features for the entire minibatch of SMILES at once, which saves the overhead of creating memory allocation and concatenation.
Additional Documentation
FileDescription
USAGE.mdExamples and instructions for using cuik-molmaker to featurize molecules including batching.
FEATURES.mdDetailed list and explanation of all atom and bond features available for featurization.
BUILD.mdStep-by-step instructions for building cuik-molmaker from source, including prerequisites and troubleshooting.
TESTING.mdGuidelines and commands for running the test suite to verify installation and functionality.
COMPATIBILITY.mdPublished package builds by release channel, OS, and Python version.
Hardware Requirements
cuik-molmaker is designed to run on any CPU-based system.
Adoption
cuik-molmaker has currently been integrated into the following projects:
  • Chemprop: cuik-molmaker is available as a featurization method in Chemprop. It can be enabled by setting --use-cuikmolmaker-featurization flag in the command line with all use cases: training, prediction, fingerprinting, and hyperparameter optimization.
  • KERMT: cuik-molmaker is available for featurizing atoms, bonds, and molecules in KERMT. Atom and bond featurization can be enabled by setting --use_cuikmolmaker_featurization flag and molecule featurization can be enabled by setting --features_generator=rdkit_2d_normalized_cuik_molmaker.
About
cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).
Resources
Readme
Contributing
Contributing
Activity
Custom properties
Stars
36 stars
Watchers
3 watching
Forks
5 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 - NVIDIA-BioNeMo/cuik-molmaker: cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs). · GitHub
Skip to content
BranchesTags
Repository files navigation
cuik-molmaker
cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).
cuik-molmaker is built as a hybrid package, leveraging both C++ and Python to deliver high performance and ease of use. The core featurization logic is implemented in C++ for maximum speed and efficiency, while the Python interface provides a user-friendly API that integrates seamlessly with modern GNN training and inference workflows. This design combines the computational power of C++ with the flexibility and accessibility of Python, making cuik-molmaker both fast and intuitive for researchers and developers. As cuik-molmaker interfaces with the C++ API of rdkit, the produced features are expected to be identical to those produced by rdkit.
Quick start
Conda installation
conda install -c conda-forge cuik_molmaker
Pip installation
python -m pip install cuik-molmaker-pin==<RDKit version>
Pip installation from NVIDIA PyPI
python -m pip install cuik-molmaker --extra-index-url https://pypi.nvidia.com/rdkit-2026.03.4/
For more information on the available versions of cuik-molmaker compatible with different versions of rdkit, refer to the COMPATIBILITY.md.
Usage: Computing atom and bond features
importcuik_molmakerimportnumpyasnp# List all available atom onehot featuresprint(cuik_molmaker.list_all_atom_onehot_features())
# Compute atom (atomic number, number of hydrogen, chirality) and bond (bond type) features for acetic acidacetic_acid_smiles="CC(=O)O"# Get atom onehot feature names as NumPy arrayatom_onehot_feature_array=cuik_molmaker.atom_onehot_feature_names_to_array(['atomic-number', 'num-hydrogens', 'chirality'])
# Get bond feature names as NumPy arraybond_feature_array=cuik_molmaker.bond_feature_names_to_array(['bond-type-onehot'])
# Set parameters for featurizationexplicit_h, offset_carbon, duplicate_edges, add_self_loop=False, False, True, False# Featurizeall_features=cuik_molmaker.mol_featurizer(acetic_acid_smiles, atom_onehot_feature_array, np.array([]), bond_feature_array, explicit_h, offset_carbon, duplicate_edges, add_self_loop)
# This returns a list of NumPy arrays.# First index contains atom featuresprint(all_features[0].shape)
# Second index contains bond featuresprint(all_features[1].shape)
# Third index contains edge indices in COO formatprint(all_features[2].shape)
Usage: Computing molecular descriptors
fromcuik_molmaker.mol_featuresimportMoleculeFeaturizerfeaturizer=MoleculeFeaturizer(molecular_descriptor_type="rdkit2D", rdkit2D_normalization_type="fast")
smiles_list= ["CC(=O)OC1=CC=CC=C1C(=O)O", # aspirin"CN(C)CCOC(C1=CC=CC=C1)C1=CC=CC=C1", # diphenhydramine
]
rdkit2D_descriptors=featurizer.featurize(smiles_list)
# Print the shape of the descriptorsprint(rdkit2D_descriptors.shape)
Source of acceleration
The hybrid C++/Python design of cuik-molmaker allows for the core featurization logic to be implemented in C++ and reduces the python overhead. Another source of acceleration is the creation of features for the entire minibatch of SMILES at once, which saves the overhead of creating memory allocation and concatenation.
Additional Documentation
FileDescription
USAGE.mdExamples and instructions for using cuik-molmaker to featurize molecules including batching.
FEATURES.mdDetailed list and explanation of all atom and bond features available for featurization.
BUILD.mdStep-by-step instructions for building cuik-molmaker from source, including prerequisites and troubleshooting.
TESTING.mdGuidelines and commands for running the test suite to verify installation and functionality.
COMPATIBILITY.mdPublished package builds by release channel, OS, and Python version.
Hardware Requirements
cuik-molmaker is designed to run on any CPU-based system.
Adoption
cuik-molmaker has currently been integrated into the following projects:
  • Chemprop: cuik-molmaker is available as a featurization method in Chemprop. It can be enabled by setting --use-cuikmolmaker-featurization flag in the command line with all use cases: training, prediction, fingerprinting, and hyperparameter optimization.
  • KERMT: cuik-molmaker is available for featurizing atoms, bonds, and molecules in KERMT. Atom and bond featurization can be enabled by setting --use_cuikmolmaker_featurization flag and molecule featurization can be enabled by setting --features_generator=rdkit_2d_normalized_cuik_molmaker.
About
cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).
Resources
Readme
Contributing
Contributing
Activity
Custom properties
Stars
36 stars
Watchers
3 watching
Forks
5 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 - NVIDIA-BioNeMo/cuik-molmaker: cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs). · GitHub
Skip to content
BranchesTags
Repository files navigation
cuik-molmaker
cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).
cuik-molmaker is built as a hybrid package, leveraging both C++ and Python to deliver high performance and ease of use. The core featurization logic is implemented in C++ for maximum speed and efficiency, while the Python interface provides a user-friendly API that integrates seamlessly with modern GNN training and inference workflows. This design combines the computational power of C++ with the flexibility and accessibility of Python, making cuik-molmaker both fast and intuitive for researchers and developers. As cuik-molmaker interfaces with the C++ API of rdkit, the produced features are expected to be identical to those produced by rdkit.
Quick start
Conda installation
conda install -c conda-forge cuik_molmaker
Pip installation
python -m pip install cuik-molmaker-pin==<RDKit version>
Pip installation from NVIDIA PyPI
python -m pip install cuik-molmaker --extra-index-url https://pypi.nvidia.com/rdkit-2026.03.4/
For more information on the available versions of cuik-molmaker compatible with different versions of rdkit, refer to the COMPATIBILITY.md.
Usage: Computing atom and bond features
importcuik_molmakerimportnumpyasnp# List all available atom onehot featuresprint(cuik_molmaker.list_all_atom_onehot_features())
# Compute atom (atomic number, number of hydrogen, chirality) and bond (bond type) features for acetic acidacetic_acid_smiles="CC(=O)O"# Get atom onehot feature names as NumPy arrayatom_onehot_feature_array=cuik_molmaker.atom_onehot_feature_names_to_array(['atomic-number', 'num-hydrogens', 'chirality'])
# Get bond feature names as NumPy arraybond_feature_array=cuik_molmaker.bond_feature_names_to_array(['bond-type-onehot'])
# Set parameters for featurizationexplicit_h, offset_carbon, duplicate_edges, add_self_loop=False, False, True, False# Featurizeall_features=cuik_molmaker.mol_featurizer(acetic_acid_smiles, atom_onehot_feature_array, np.array([]), bond_feature_array, explicit_h, offset_carbon, duplicate_edges, add_self_loop)
# This returns a list of NumPy arrays.# First index contains atom featuresprint(all_features[0].shape)
# Second index contains bond featuresprint(all_features[1].shape)
# Third index contains edge indices in COO formatprint(all_features[2].shape)
Usage: Computing molecular descriptors
fromcuik_molmaker.mol_featuresimportMoleculeFeaturizerfeaturizer=MoleculeFeaturizer(molecular_descriptor_type="rdkit2D", rdkit2D_normalization_type="fast")
smiles_list= ["CC(=O)OC1=CC=CC=C1C(=O)O", # aspirin"CN(C)CCOC(C1=CC=CC=C1)C1=CC=CC=C1", # diphenhydramine
]
rdkit2D_descriptors=featurizer.featurize(smiles_list)
# Print the shape of the descriptorsprint(rdkit2D_descriptors.shape)
Source of acceleration
The hybrid C++/Python design of cuik-molmaker allows for the core featurization logic to be implemented in C++ and reduces the python overhead. Another source of acceleration is the creation of features for the entire minibatch of SMILES at once, which saves the overhead of creating memory allocation and concatenation.
Additional Documentation
FileDescription
USAGE.mdExamples and instructions for using cuik-molmaker to featurize molecules including batching.
FEATURES.mdDetailed list and explanation of all atom and bond features available for featurization.
BUILD.mdStep-by-step instructions for building cuik-molmaker from source, including prerequisites and troubleshooting.
TESTING.mdGuidelines and commands for running the test suite to verify installation and functionality.
COMPATIBILITY.mdPublished package builds by release channel, OS, and Python version.
Hardware Requirements
cuik-molmaker is designed to run on any CPU-based system.
Adoption
cuik-molmaker has currently been integrated into the following projects:
  • Chemprop: cuik-molmaker is available as a featurization method in Chemprop. It can be enabled by setting --use-cuikmolmaker-featurization flag in the command line with all use cases: training, prediction, fingerprinting, and hyperparameter optimization.
  • KERMT: cuik-molmaker is available for featurizing atoms, bonds, and molecules in KERMT. Atom and bond featurization can be enabled by setting --use_cuikmolmaker_featurization flag and molecule featurization can be enabled by setting --features_generator=rdkit_2d_normalized_cuik_molmaker.
About
cuik-molmaker is a specialized package designed for molecular featurization, converting chemical structures into formats that can be effectively used as inputs for deep learning models, particularly graph neural networks (GNNs).
Resources
Readme
Contributing
Contributing
Activity
Custom properties
Stars
36 stars
Watchers
3 watching
Forks
5 forks
Report repository
Releases
Packages
Contributors
Languages