No version for distro humble showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro jazzy showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro kilted showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version rolling
Last Updated 2026-08-26
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro ardent showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro bouncy showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro crystal showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro eloquent showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro dashing showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro galactic showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro foxy showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro iron showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro lunar showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro jade showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro indigo showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro hydro showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro kinetic showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro melodic showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.

No version for distro noetic showing lyrical. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/dskkato/memfd_buffer_backend.git
VCS Type git
VCS Version lyrical
Last Updated 2026-08-25
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

memfd_buffer_backend

memfd_buffer_backend is a Linux-only rosidl::Buffer backend that shares same-host, same-UID memfd allocations between ROS 2 endpoints.

Attribution

This repository is developed and maintained outside the Open Source Robotics Foundation (OSRF). Its implementation was developed with reference to the OSRF rosidl_buffer_backends implementation.

Packages

  • memfd_buffer: memfd allocation, pooling, handles, and FD brokering.
  • memfd_buffer_backend_py: Python zero-copy bindings for the memfd backend (installs the memfd_buffer Python module).
  • memfd_buffer_backend: rosidl buffer backend plugin.
  • memfd_buffer_backend_msgs: descriptor message used for inter-process import.

Python zero-copy access

The memfd_buffer_backend_py package exposes scoped Python buffer-protocol access through the memfd_buffer Python module. NumPy is optional and consumes the standard memoryview without copying:

import numpy as np
from memfd_buffer import allocate_buffer, read_buffer, write_buffer

buffer = allocate_buffer(1024)
with write_buffer(buffer) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    array[:] = 7
    del array  # Derived views must be released before leaving the scope.

message.data = buffer

with read_buffer(received_message.data) as view:
    array = np.frombuffer(view, dtype=np.uint8)
    process(array)
    del array  # Derived views must be released before leaving the scope.

Read views are read-only. Write views are exclusive and are finalized when the scope closes. A derived view must not escape the scope; closing raises BufferError while an exported NumPy or memoryview object remains alive.

Benchmark

The benchmark package, benchmark results, report, and figures are maintained in the separate memfd_buffer_backend_benchmark repository.