Skip to content
BranchesTags

Latest commit

History

18,052 Commits

Folders and files

NameName
Last commit message
Last commit date
.github
.github
c_glib
c_glib
ci
ci
cpp
cpp
dev
dev
docs
docs
format
format
matlab
matlab
python
python
r
r
ruby
ruby
testing @ 725fd4a
testing @ 725fd4a
.asf.yaml
.asf.yaml
.clang-format
.clang-format
.clang-tidy
.clang-tidy
.clang-tidy-ignore
.clang-tidy-ignore
.dockerignore
.dockerignore
.editorconfig
.editorconfig
.env
.env
.gitattributes
.gitattributes
.gitignore
.gitignore
.gitmodules
.gitmodules
.hadolint.yaml
.hadolint.yaml
.pre-commit-config.yaml
.pre-commit-config.yaml
.rubocop.yml
.rubocop.yml
.shellcheckrc
.shellcheckrc
CHANGELOG.md
CHANGELOG.md
CODE_OF_CONDUCT.md
CODE_OF_CONDUCT.md
CONTRIBUTING.md
CONTRIBUTING.md
CPPLINT.cfg
CPPLINT.cfg
LICENSE.txt
LICENSE.txt
NOTICE.txt
NOTICE.txt
README.md
README.md
cmake-format.py
cmake-format.py
docker-compose.yml
docker-compose.yml

Repository files navigation

Apache Arrow

Fuzzing StatusLicenseBlueSky Follow

Powering In-Memory Analytics

Apache Arrow is a universal columnar format and multi-language toolbox for fast data interchange and in-memory analytics. It contains a set of technologies that enable data systems to efficiently store, process, and move data.

Major components of the project include:

The ↗ icon denotes that this component of the project is maintained in a separate repository.

Arrow is an Apache Software Foundation project. Learn more at arrow.apache.org.

What's in the Arrow libraries?

The reference Arrow libraries contain many distinct software components:

  • Columnar vector and table-like containers (similar to data frames) supporting flat or nested types
  • Fast, language agnostic metadata messaging layer (using Google's Flatbuffers library)
  • Reference-counted off-heap buffer memory management, for zero-copy memory sharing and handling memory-mapped files
  • IO interfaces to local and remote filesystems
  • Self-describing binary wire formats (streaming and batch/file-like) for remote procedure calls (RPC) and interprocess communication (IPC)
  • Integration tests for verifying binary compatibility between the implementations (e.g. sending data from Java to C++)
  • Conversions to and from other in-memory data structures
  • Readers and writers for various widely-used file formats (such as Parquet, CSV)

Implementation status

The official Arrow libraries in this repository are in different stages of implementing the Arrow format and related features. See our current feature matrix on git main.

How to Contribute

Please read our latest project contribution guide.

Getting involved

Even if you do not plan to contribute to Apache Arrow itself or Arrow integrations in other projects, we'd be happy to have you involved:

About

Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing

arrow.apache.org/

Resources

Readme
Apache-2.0 license

Code of conduct

Code of conduct

Contributing

Contributing
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 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 - aboyoun/arrow: Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing · GitHub
Skip to content
BranchesTags
Latest commit
History
18,052 Commits
Folders and files
NameName
Last commit message
Last commit date
.github
.github
c_glib
c_glib
ci
ci
cpp
cpp
dev
dev
docs
docs
format
format
matlab
matlab
python
python
r
r
ruby
ruby
testing @ 725fd4a
testing @ 725fd4a
.asf.yaml
.asf.yaml
.clang-format
.clang-format
.clang-tidy
.clang-tidy
.clang-tidy-ignore
.clang-tidy-ignore
.dockerignore
.dockerignore
.editorconfig
.editorconfig
.env
.env
.gitattributes
.gitattributes
.gitignore
.gitignore
.gitmodules
.gitmodules
.hadolint.yaml
.hadolint.yaml
.pre-commit-config.yaml
.pre-commit-config.yaml
.rubocop.yml
.rubocop.yml
.shellcheckrc
.shellcheckrc
CHANGELOG.md
CHANGELOG.md
CODE_OF_CONDUCT.md
CODE_OF_CONDUCT.md
CONTRIBUTING.md
CONTRIBUTING.md
CPPLINT.cfg
CPPLINT.cfg
LICENSE.txt
LICENSE.txt
NOTICE.txt
NOTICE.txt
README.md
README.md
cmake-format.py
cmake-format.py
docker-compose.yml
docker-compose.yml
Repository files navigation
Apache Arrow
Fuzzing StatusLicenseBlueSky Follow
Powering In-Memory Analytics
Apache Arrow is a universal columnar format and multi-language toolbox for fast
data interchange and in-memory analytics. It contains a set of technologies that
enable data systems to efficiently store, process, and move data.
Major components of the project include:
The ↗ icon denotes that this component of the project is maintained in a separate
repository.
Arrow is an Apache Software Foundation project. Learn more at
arrow.apache.org.
What's in the Arrow libraries?
The reference Arrow libraries contain many distinct software components:
  • Columnar vector and table-like containers (similar to data frames) supporting
flat or nested types
  • Fast, language agnostic metadata messaging layer (using Google's Flatbuffers
library)
  • Reference-counted off-heap buffer memory management, for zero-copy memory
sharing and handling memory-mapped files
  • IO interfaces to local and remote filesystems
  • Self-describing binary wire formats (streaming and batch/file-like) for
remote procedure calls (RPC) and interprocess communication (IPC)
  • Integration tests for verifying binary compatibility between the
implementations (e.g. sending data from Java to C++)
  • Conversions to and from other in-memory data structures
  • Readers and writers for various widely-used file formats (such as Parquet, CSV)
Implementation status
The official Arrow libraries in this repository are in different stages of
implementing the Arrow format and related features. See our current
feature matrix
on git main.
How to Contribute
Please read our latest project contribution guide.
Getting involved
Even if you do not plan to contribute to Apache Arrow itself or Arrow
integrations in other projects, we'd be happy to have you involved:
About
Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing
arrow.apache.org/
Resources
Readme
Apache-2.0 license
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 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 - aboyoun/arrow: Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing · GitHub
Skip to content
BranchesTags
Latest commit
History
18,052 Commits
Folders and files
NameName
Last commit message
Last commit date
.github
.github
c_glib
c_glib
ci
ci
cpp
cpp
dev
dev
docs
docs
format
format
matlab
matlab
python
python
r
r
ruby
ruby
testing @ 725fd4a
testing @ 725fd4a
.asf.yaml
.asf.yaml
.clang-format
.clang-format
.clang-tidy
.clang-tidy
.clang-tidy-ignore
.clang-tidy-ignore
.dockerignore
.dockerignore
.editorconfig
.editorconfig
.env
.env
.gitattributes
.gitattributes
.gitignore
.gitignore
.gitmodules
.gitmodules
.hadolint.yaml
.hadolint.yaml
.pre-commit-config.yaml
.pre-commit-config.yaml
.rubocop.yml
.rubocop.yml
.shellcheckrc
.shellcheckrc
CHANGELOG.md
CHANGELOG.md
CODE_OF_CONDUCT.md
CODE_OF_CONDUCT.md
CONTRIBUTING.md
CONTRIBUTING.md
CPPLINT.cfg
CPPLINT.cfg
LICENSE.txt
LICENSE.txt
NOTICE.txt
NOTICE.txt
README.md
README.md
cmake-format.py
cmake-format.py
docker-compose.yml
docker-compose.yml
Repository files navigation
Apache Arrow
Fuzzing StatusLicenseBlueSky Follow
Powering In-Memory Analytics
Apache Arrow is a universal columnar format and multi-language toolbox for fast
data interchange and in-memory analytics. It contains a set of technologies that
enable data systems to efficiently store, process, and move data.
Major components of the project include:
The ↗ icon denotes that this component of the project is maintained in a separate
repository.
Arrow is an Apache Software Foundation project. Learn more at
arrow.apache.org.
What's in the Arrow libraries?
The reference Arrow libraries contain many distinct software components:
  • Columnar vector and table-like containers (similar to data frames) supporting
flat or nested types
  • Fast, language agnostic metadata messaging layer (using Google's Flatbuffers
library)
  • Reference-counted off-heap buffer memory management, for zero-copy memory
sharing and handling memory-mapped files
  • IO interfaces to local and remote filesystems
  • Self-describing binary wire formats (streaming and batch/file-like) for
remote procedure calls (RPC) and interprocess communication (IPC)
  • Integration tests for verifying binary compatibility between the
implementations (e.g. sending data from Java to C++)
  • Conversions to and from other in-memory data structures
  • Readers and writers for various widely-used file formats (such as Parquet, CSV)
Implementation status
The official Arrow libraries in this repository are in different stages of
implementing the Arrow format and related features. See our current
feature matrix
on git main.
How to Contribute
Please read our latest project contribution guide.
Getting involved
Even if you do not plan to contribute to Apache Arrow itself or Arrow
integrations in other projects, we'd be happy to have you involved:
About
Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing
arrow.apache.org/
Resources
Readme
Apache-2.0 license
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 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 - aboyoun/arrow: Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing · GitHub
Skip to content
BranchesTags
Latest commit
History
18,052 Commits
Folders and files
NameName
Last commit message
Last commit date
.github
.github
c_glib
c_glib
ci
ci
cpp
cpp
dev
dev
docs
docs
format
format
matlab
matlab
python
python
r
r
ruby
ruby
testing @ 725fd4a
testing @ 725fd4a
.asf.yaml
.asf.yaml
.clang-format
.clang-format
.clang-tidy
.clang-tidy
.clang-tidy-ignore
.clang-tidy-ignore
.dockerignore
.dockerignore
.editorconfig
.editorconfig
.env
.env
.gitattributes
.gitattributes
.gitignore
.gitignore
.gitmodules
.gitmodules
.hadolint.yaml
.hadolint.yaml
.pre-commit-config.yaml
.pre-commit-config.yaml
.rubocop.yml
.rubocop.yml
.shellcheckrc
.shellcheckrc
CHANGELOG.md
CHANGELOG.md
CODE_OF_CONDUCT.md
CODE_OF_CONDUCT.md
CONTRIBUTING.md
CONTRIBUTING.md
CPPLINT.cfg
CPPLINT.cfg
LICENSE.txt
LICENSE.txt
NOTICE.txt
NOTICE.txt
README.md
README.md
cmake-format.py
cmake-format.py
docker-compose.yml
docker-compose.yml
Repository files navigation
Apache Arrow
Fuzzing StatusLicenseBlueSky Follow
Powering In-Memory Analytics
Apache Arrow is a universal columnar format and multi-language toolbox for fast
data interchange and in-memory analytics. It contains a set of technologies that
enable data systems to efficiently store, process, and move data.
Major components of the project include:
The ↗ icon denotes that this component of the project is maintained in a separate
repository.
Arrow is an Apache Software Foundation project. Learn more at
arrow.apache.org.
What's in the Arrow libraries?
The reference Arrow libraries contain many distinct software components:
  • Columnar vector and table-like containers (similar to data frames) supporting
flat or nested types
  • Fast, language agnostic metadata messaging layer (using Google's Flatbuffers
library)
  • Reference-counted off-heap buffer memory management, for zero-copy memory
sharing and handling memory-mapped files
  • IO interfaces to local and remote filesystems
  • Self-describing binary wire formats (streaming and batch/file-like) for
remote procedure calls (RPC) and interprocess communication (IPC)
  • Integration tests for verifying binary compatibility between the
implementations (e.g. sending data from Java to C++)
  • Conversions to and from other in-memory data structures
  • Readers and writers for various widely-used file formats (such as Parquet, CSV)
Implementation status
The official Arrow libraries in this repository are in different stages of
implementing the Arrow format and related features. See our current
feature matrix
on git main.
How to Contribute
Please read our latest project contribution guide.
Getting involved
Even if you do not plan to contribute to Apache Arrow itself or Arrow
integrations in other projects, we'd be happy to have you involved:
About
Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing
arrow.apache.org/
Resources
Readme
Apache-2.0 license
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 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 - aboyoun/arrow: Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing · GitHub
Skip to content
BranchesTags
Latest commit
History
18,052 Commits
Folders and files
NameName
Last commit message
Last commit date
.github
.github
c_glib
c_glib
ci
ci
cpp
cpp
dev
dev
docs
docs
format
format
matlab
matlab
python
python
r
r
ruby
ruby
testing @ 725fd4a
testing @ 725fd4a
.asf.yaml
.asf.yaml
.clang-format
.clang-format
.clang-tidy
.clang-tidy
.clang-tidy-ignore
.clang-tidy-ignore
.dockerignore
.dockerignore
.editorconfig
.editorconfig
.env
.env
.gitattributes
.gitattributes
.gitignore
.gitignore
.gitmodules
.gitmodules
.hadolint.yaml
.hadolint.yaml
.pre-commit-config.yaml
.pre-commit-config.yaml
.rubocop.yml
.rubocop.yml
.shellcheckrc
.shellcheckrc
CHANGELOG.md
CHANGELOG.md
CODE_OF_CONDUCT.md
CODE_OF_CONDUCT.md
CONTRIBUTING.md
CONTRIBUTING.md
CPPLINT.cfg
CPPLINT.cfg
LICENSE.txt
LICENSE.txt
NOTICE.txt
NOTICE.txt
README.md
README.md
cmake-format.py
cmake-format.py
docker-compose.yml
docker-compose.yml
Repository files navigation
Apache Arrow
Fuzzing StatusLicenseBlueSky Follow
Powering In-Memory Analytics
Apache Arrow is a universal columnar format and multi-language toolbox for fast
data interchange and in-memory analytics. It contains a set of technologies that
enable data systems to efficiently store, process, and move data.
Major components of the project include:
The ↗ icon denotes that this component of the project is maintained in a separate
repository.
Arrow is an Apache Software Foundation project. Learn more at
arrow.apache.org.
What's in the Arrow libraries?
The reference Arrow libraries contain many distinct software components:
  • Columnar vector and table-like containers (similar to data frames) supporting
flat or nested types
  • Fast, language agnostic metadata messaging layer (using Google's Flatbuffers
library)
  • Reference-counted off-heap buffer memory management, for zero-copy memory
sharing and handling memory-mapped files
  • IO interfaces to local and remote filesystems
  • Self-describing binary wire formats (streaming and batch/file-like) for
remote procedure calls (RPC) and interprocess communication (IPC)
  • Integration tests for verifying binary compatibility between the
implementations (e.g. sending data from Java to C++)
  • Conversions to and from other in-memory data structures
  • Readers and writers for various widely-used file formats (such as Parquet, CSV)
Implementation status
The official Arrow libraries in this repository are in different stages of
implementing the Arrow format and related features. See our current
feature matrix
on git main.
How to Contribute
Please read our latest project contribution guide.
Getting involved
Even if you do not plan to contribute to Apache Arrow itself or Arrow
integrations in other projects, we'd be happy to have you involved:
About
Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing
arrow.apache.org/
Resources
Readme
Apache-2.0 license
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 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 - aboyoun/arrow: Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing · GitHub
Skip to content
BranchesTags
Latest commit
History
18,052 Commits
Folders and files
NameName
Last commit message
Last commit date
.github
.github
c_glib
c_glib
ci
ci
cpp
cpp
dev
dev
docs
docs
format
format
matlab
matlab
python
python
r
r
ruby
ruby
testing @ 725fd4a
testing @ 725fd4a
.asf.yaml
.asf.yaml
.clang-format
.clang-format
.clang-tidy
.clang-tidy
.clang-tidy-ignore
.clang-tidy-ignore
.dockerignore
.dockerignore
.editorconfig
.editorconfig
.env
.env
.gitattributes
.gitattributes
.gitignore
.gitignore
.gitmodules
.gitmodules
.hadolint.yaml
.hadolint.yaml
.pre-commit-config.yaml
.pre-commit-config.yaml
.rubocop.yml
.rubocop.yml
.shellcheckrc
.shellcheckrc
CHANGELOG.md
CHANGELOG.md
CODE_OF_CONDUCT.md
CODE_OF_CONDUCT.md
CONTRIBUTING.md
CONTRIBUTING.md
CPPLINT.cfg
CPPLINT.cfg
LICENSE.txt
LICENSE.txt
NOTICE.txt
NOTICE.txt
README.md
README.md
cmake-format.py
cmake-format.py
docker-compose.yml
docker-compose.yml
Repository files navigation
Apache Arrow
Fuzzing StatusLicenseBlueSky Follow
Powering In-Memory Analytics
Apache Arrow is a universal columnar format and multi-language toolbox for fast
data interchange and in-memory analytics. It contains a set of technologies that
enable data systems to efficiently store, process, and move data.
Major components of the project include:
The ↗ icon denotes that this component of the project is maintained in a separate
repository.
Arrow is an Apache Software Foundation project. Learn more at
arrow.apache.org.
What's in the Arrow libraries?
The reference Arrow libraries contain many distinct software components:
  • Columnar vector and table-like containers (similar to data frames) supporting
flat or nested types
  • Fast, language agnostic metadata messaging layer (using Google's Flatbuffers
library)
  • Reference-counted off-heap buffer memory management, for zero-copy memory
sharing and handling memory-mapped files
  • IO interfaces to local and remote filesystems
  • Self-describing binary wire formats (streaming and batch/file-like) for
remote procedure calls (RPC) and interprocess communication (IPC)
  • Integration tests for verifying binary compatibility between the
implementations (e.g. sending data from Java to C++)
  • Conversions to and from other in-memory data structures
  • Readers and writers for various widely-used file formats (such as Parquet, CSV)
Implementation status
The official Arrow libraries in this repository are in different stages of
implementing the Arrow format and related features. See our current
feature matrix
on git main.
How to Contribute
Please read our latest project contribution guide.
Getting involved
Even if you do not plan to contribute to Apache Arrow itself or Arrow
integrations in other projects, we'd be happy to have you involved:
About
Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing
arrow.apache.org/
Resources
Readme
Apache-2.0 license
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 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 - aboyoun/arrow: Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing · GitHub
Skip to content
BranchesTags
Latest commit
History
18,052 Commits
Folders and files
NameName
Last commit message
Last commit date
.github
.github
c_glib
c_glib
ci
ci
cpp
cpp
dev
dev
docs
docs
format
format
matlab
matlab
python
python
r
r
ruby
ruby
testing @ 725fd4a
testing @ 725fd4a
.asf.yaml
.asf.yaml
.clang-format
.clang-format
.clang-tidy
.clang-tidy
.clang-tidy-ignore
.clang-tidy-ignore
.dockerignore
.dockerignore
.editorconfig
.editorconfig
.env
.env
.gitattributes
.gitattributes
.gitignore
.gitignore
.gitmodules
.gitmodules
.hadolint.yaml
.hadolint.yaml
.pre-commit-config.yaml
.pre-commit-config.yaml
.rubocop.yml
.rubocop.yml
.shellcheckrc
.shellcheckrc
CHANGELOG.md
CHANGELOG.md
CODE_OF_CONDUCT.md
CODE_OF_CONDUCT.md
CONTRIBUTING.md
CONTRIBUTING.md
CPPLINT.cfg
CPPLINT.cfg
LICENSE.txt
LICENSE.txt
NOTICE.txt
NOTICE.txt
README.md
README.md
cmake-format.py
cmake-format.py
docker-compose.yml
docker-compose.yml
Repository files navigation
Apache Arrow
Fuzzing StatusLicenseBlueSky Follow
Powering In-Memory Analytics
Apache Arrow is a universal columnar format and multi-language toolbox for fast
data interchange and in-memory analytics. It contains a set of technologies that
enable data systems to efficiently store, process, and move data.
Major components of the project include:
The ↗ icon denotes that this component of the project is maintained in a separate
repository.
Arrow is an Apache Software Foundation project. Learn more at
arrow.apache.org.
What's in the Arrow libraries?
The reference Arrow libraries contain many distinct software components:
  • Columnar vector and table-like containers (similar to data frames) supporting
flat or nested types
  • Fast, language agnostic metadata messaging layer (using Google's Flatbuffers
library)
  • Reference-counted off-heap buffer memory management, for zero-copy memory
sharing and handling memory-mapped files
  • IO interfaces to local and remote filesystems
  • Self-describing binary wire formats (streaming and batch/file-like) for
remote procedure calls (RPC) and interprocess communication (IPC)
  • Integration tests for verifying binary compatibility between the
implementations (e.g. sending data from Java to C++)
  • Conversions to and from other in-memory data structures
  • Readers and writers for various widely-used file formats (such as Parquet, CSV)
Implementation status
The official Arrow libraries in this repository are in different stages of
implementing the Arrow format and related features. See our current
feature matrix
on git main.
How to Contribute
Please read our latest project contribution guide.
Getting involved
Even if you do not plan to contribute to Apache Arrow itself or Arrow
integrations in other projects, we'd be happy to have you involved:
About
Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing
arrow.apache.org/
Resources
Readme
Apache-2.0 license
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 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 - aboyoun/arrow: Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing · GitHub
Skip to content
BranchesTags
Latest commit
History
18,052 Commits
Folders and files
NameName
Last commit message
Last commit date
.github
.github
c_glib
c_glib
ci
ci
cpp
cpp
dev
dev
docs
docs
format
format
matlab
matlab
python
python
r
r
ruby
ruby
testing @ 725fd4a
testing @ 725fd4a
.asf.yaml
.asf.yaml
.clang-format
.clang-format
.clang-tidy
.clang-tidy
.clang-tidy-ignore
.clang-tidy-ignore
.dockerignore
.dockerignore
.editorconfig
.editorconfig
.env
.env
.gitattributes
.gitattributes
.gitignore
.gitignore
.gitmodules
.gitmodules
.hadolint.yaml
.hadolint.yaml
.pre-commit-config.yaml
.pre-commit-config.yaml
.rubocop.yml
.rubocop.yml
.shellcheckrc
.shellcheckrc
CHANGELOG.md
CHANGELOG.md
CODE_OF_CONDUCT.md
CODE_OF_CONDUCT.md
CONTRIBUTING.md
CONTRIBUTING.md
CPPLINT.cfg
CPPLINT.cfg
LICENSE.txt
LICENSE.txt
NOTICE.txt
NOTICE.txt
README.md
README.md
cmake-format.py
cmake-format.py
docker-compose.yml
docker-compose.yml
Repository files navigation
Apache Arrow
Fuzzing StatusLicenseBlueSky Follow
Powering In-Memory Analytics
Apache Arrow is a universal columnar format and multi-language toolbox for fast
data interchange and in-memory analytics. It contains a set of technologies that
enable data systems to efficiently store, process, and move data.
Major components of the project include:
The ↗ icon denotes that this component of the project is maintained in a separate
repository.
Arrow is an Apache Software Foundation project. Learn more at
arrow.apache.org.
What's in the Arrow libraries?
The reference Arrow libraries contain many distinct software components:
  • Columnar vector and table-like containers (similar to data frames) supporting
flat or nested types
  • Fast, language agnostic metadata messaging layer (using Google's Flatbuffers
library)
  • Reference-counted off-heap buffer memory management, for zero-copy memory
sharing and handling memory-mapped files
  • IO interfaces to local and remote filesystems
  • Self-describing binary wire formats (streaming and batch/file-like) for
remote procedure calls (RPC) and interprocess communication (IPC)
  • Integration tests for verifying binary compatibility between the
implementations (e.g. sending data from Java to C++)
  • Conversions to and from other in-memory data structures
  • Readers and writers for various widely-used file formats (such as Parquet, CSV)
Implementation status
The official Arrow libraries in this repository are in different stages of
implementing the Arrow format and related features. See our current
feature matrix
on git main.
How to Contribute
Please read our latest project contribution guide.
Getting involved
Even if you do not plan to contribute to Apache Arrow itself or Arrow
integrations in other projects, we'd be happy to have you involved:
About
Apache Arrow is a multi-language toolbox for accelerated data interchange and in-memory processing
arrow.apache.org/
Resources
Readme
Apache-2.0 license
Code of conduct
Code of conduct
Contributing
Contributing
Activity
Stars
0 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages