groggy 0.5.2

Release Notes: Groggy 0.5.2

Release Date: December 5, 2024

🎯 Release Overview

Groggy 0.5.2 introduces production-ready algorithms and a 10-100x performance boost for iterative computations through the new Batch Executor. This release transforms Groggy from an experimental framework into a practical graph analytics library with 11 native algorithms and a flexible Builder DSL for custom algorithm development.

---

✨ Major Features

1. Native Algorithms Module (groggy.algorithms)

Eleven battle-tested, high-performance algorithms implemented in Rust and exposed through a clean Python API:

Centrality Algorithms

• PageRank (pagerank()) - Web-scale ranking with damping factor support
• Betweenness Centrality (betweenness()) - Bridge detection and influence measurement
• Closeness Centrality (closeness()) - Reachability and accessibility analysis

Community Detection

• Label Propagation (lpa()) - Fast community detection for large graphs
• Louvain Modularity (louvain()) - Hierarchical community optimization
• Leiden Algorithm (leiden()) - Improved modularity with quality guarantees
• Connected Components (connected_components()) - Graph partitioning and clustering

Pathfinding

• Breadth-First Search (bfs()) - Level-by-level graph traversal
• Depth-First Search (dfs()) - Deep exploration with backtracking
• Dijkstra's Algorithm (dijkstra()) - Weighted shortest paths
• A Search* (astar()) - Heuristic-guided pathfinding

Usage Example:

from groggy.algorithms.centrality import pagerank
from groggy.algorithms.community import lpa

# Run PageRank
result = graph.view().apply(pagerank(damping=0.85, max_iter=100))
scores = result.nodes["pagerank"]

# Detect communities
communities = graph.view().apply(lpa(max_iter=50))
labels = communities.nodes["label"]

2. Batch Executor — 10-100x Performance Improvement

The new Batch Executor automatically optimizes iterative loops in Builder DSL algorithms by:

• Compiling loop bodies into structured execution plans
• Eliminating redundant Python-Rust FFI calls (100ns overhead each)
• Enabling future JIT compilation to native code
• Gracefully falling back to step-by-step execution for unsupported operations

Performance Impact:

# Before: 20 iterations = 20 × (5 operations × 100ns FFI) = ~10µs overhead
# After:  20 iterations = 1 FFI call = ~100ns overhead
# Result: 100x reduction in FFI overhead alone

Automatic Optimization:

import groggy as gr

b = gr.builder("pagerank")
ranks = b.init_nodes(default=1.0)

# This loop gets batch-optimized automatically
with b.iterate(20):
    neighbor_sum = b.map_nodes(
        "sum(ranks[neighbors(node)])",
        inputs={"ranks": ranks}
    )
    ranks = b.core.add(b.core.mul(neighbor_sum, 0.85), 0.15)

b.attach_as("rank", ranks)
algo = b.build()

3. Builder DSL Maturity

The Builder DSL is now production-ready with comprehensive documentation, tutorials, and validation:

• 6 Complete Tutorials covering basic operations to advanced patterns
• Full API Documentation with examples for every operation
• Validated Implementations of PageRank and LPA matching native algorithm behavior
• Structured IR Pipeline enabling optimization and analysis

Key Builder Operations:

• Graph topology: neighbors(), in_neighbors(), out_neighbors()
• Node operations: map_nodes(), init_nodes(), filter_nodes()
• Aggregation: sum(), mean(), min(), max(), count()
• Core ops: add, mul, div, sub, constant
• Control flow: iterate(), select(), conditional logic

---

🐛 Critical Bug Fixes

Batch Executor Variable Mapping

Issue: Loop-carried variables in batch-compiled loops used internal IR variable names instead of actual property names, causing "variable not stored" errors in multi-iteration algorithms.

Fix: Corrected LoadNodeProp/StoreNodeProp instructions to use proper storage names, enabling reliable execution of PageRank, LPA, and other iterative algorithms.

Batch Compilation Validation

Issue: Batch compiler attempted to optimize loops containing unsupported operations (e.g., node_degree, scalar operations), leading to runtime failures.

Fix: Added pre-compilation compatibility checks that gracefully fall back to step-by-step execution when batch optimization isn't supported, with clear diagnostic messages.

Algorithm Correctness

• PageRank: Fixed builder implementation to match native algorithm semantics (precomputed out-degrees, sink redistribution, proper normalization)
• Histogram IR: Preserved source field during IR conversion
• Node Degrees: Corrected test expectations for directed graphs
• Loop Variable Slots: Fixed slot allocation for multi-iteration algorithms

---

📚 Documentation Overhaul

New Documentation Structure

docs/
├── guide/
│   ├── algorithms/
│   │   ├── index.md          # Overview of all 11 algorithms
│   │   ├── native.md          # Native algorithm guide
│   │   └── builder.md         # Custom algorithm development
│   └── builder/
│       ├── index.md           # Builder DSL introduction
│       └── api/               # Complete API reference
│           ├── initialization.md
│           ├── graph_topology.md
│           ├── node_operations.md
│           ├── aggregation.md
│           ├── core_operations.md
│           └── control_flow.md
├── builder/tutorials/
│   ├── 01_hello_world.md     # First algorithm
│   ├── 02_aggregation.md     # Neighbor operations
│   ├── 03_iteration.md       # Multi-iteration loops
│   ├── 04_conditionals.md    # Branching logic
│   ├── 05_advanced_patterns.md
│   └── 06_troubleshooting.md
└── api/                       # Python API reference

Documentation Highlights

• Algorithm Guide: Complete reference for all 11 native algorithms with parameters, return values, and usage examples
• Builder DSL Guide: End-to-end documentation from basics to advanced patterns
• 6 Tutorials: Progressive learning path from "Hello World" to complex algorithms
• API Reference: Comprehensive documentation of every Builder operation
• Troubleshooting Guide: Common issues and solutions for algorithm development

---

🔧 Breaking Changes

Namespace Consolidation

To improve API clarity and consistency:

# Before
builder.init_scalar(42)
builder.load_edge_attr("weight")

# After
builder.core.constant(42)
builder.graph.load_edge_attr("weight")

Migration: Update algorithm code to use the new namespaced operations. The compiler will provide clear error messages for deprecated operations.

---

🧪 Testing & Quality

Test Suite Status

• 46/46 tests passing (100% pass rate)
• Fixed 16 test failures from previous release
• Comprehensive algorithm validation
• Builder DSL correctness tests
• IR optimization test coverage

Code Quality

• Zero Clippy warnings with strict lints enabled
• Resolved 45 style issues systematically
• Proper error handling throughout codebase
• FFI safety guarantees maintained

---

📊 Performance Characteristics

Batch Executor Impact

Algorithm	Step-by-Step	Batched	Improvement
PageRank (20 iter)	~200µs FFI	~100ns FFI	~2000x overhead reduction
LPA (50 iter)	~500µs FFI	~100ns FFI	~5000x overhead reduction

Note: These numbers reflect FFI overhead only. Total runtime improvement depends on algorithm complexity and graph size.

Native Algorithm Performance

• PageRank: O(E × k) where E = edges, k = iterations
• BFS/DFS: O(V + E) linear traversal
• Dijkstra: O((V + E) log V) with binary heap
• Connected Components: O(V + E) union-find
• LPA: O(E × k) probabilistic convergence

---

⚠️ Known Issues

JIT Compilation (Blocked for v0.5.2)

The experimental JIT compilation feature from the Tier 2 roadmap has been temporarily disabled due to thread-safety issues with Cranelift's JITModule. The LoopStep implementation requires Send + Sync traits, but Cranelift's function resolver callbacks are not thread-safe.

Status: This issue blocks the JIT functionality but does not affect any other features in this release. All native algorithms and the batch executor work correctly.

Workaround: Algorithms will use the interpreted batch executor path, which still provides 10-100x performance improvements over the naive FFI approach.

Resolution Plan: We're tracking upstream Cranelift development and will re-enable JIT in v0.6.0 once thread-safe symbol resolution is available or we implement an alternative architecture.

---

🚀 What's Next

Tier 2: JIT Compilation (v0.6.0 - In Progress)

• Native code generation from batch execution plans
• Direct LLVM IR emission for maximum performance
• Target: Single-digit nanosecond per-iteration overhead

Tier 3: Native Templates (v0.7.0)

• Reusable algorithm templates (PageRank, LPA patterns)
• Template composition and specialization
• Library of high-performance building blocks

Enhanced Algorithms

• Additional centrality metrics (eigenvector, Katz)
• Advanced community detection (spectral clustering)
• Graph neural network primitives

---

🙏 Acknowledgments

This release represents months of focused development on core infrastructure, algorithm implementation, and performance optimization. Special thanks to the Rust and PyO3 communities for building the foundational tools that make Groggy possible.

---

📦 Installation & Upgrade

New Installation

pip install groggy==0.5.2

Upgrade from 0.5.1

`...

groggy 0.5.1

👀 groggy 0.5.1 · A Graph Analytics Platform Release

Groggy graduates from “graph helper” to a full analytics platform with visualization, matrices, tables,
and neural foundations—all backed by a 400+ test suite.

Highlights

• Visualization engine
  Real-time streaming viz, multiple embeddings (spectral, force-directed, honeycomb), interactive web
  viewer, Jupyter integration, and themeable CSS.
• Advanced matrices & auto-diff
  Unified matrix system with 80+ ops, SIMD acceleration, auto-diff/gradient engine, convolution
  primitives—ready for neural layers.
• Table overhaul
  DataFrame-style BaseTable, specialized Nodes/Edges tables, group-by + aggregation, CSV/JSON/Parquet
  IO, pandas bridge, rich display.
• Array enhancements
  Lazy BaseArray/NumArray/BoolArray with SIMD/statistics/lazy iterators and memory profiling.
• Comprehensive import/export
  Graph bundle save/load, NetworkX adapters, SciPy/NumPy/Pandas bridges.
• Meta-API discovery
  Automated introspection, 7k-line API graph, doc/test generation.

Under the hood

• Modular FFI + core layout (storage/, viz/, query/, etc.).
• 406 automated tests plus fixtures with real datasets.
• 9k-line Python stubs for IDE support.
• SIMD + lazy execution → 2‑10× faster numerics, 20× faster PyGraph delegation.
• Extensive docs, tutorials, performance guides.

Quick start

pip install groggy

Need help? See the docs bundle or open an issue. This release makes Groggy production-ready for
exploratory analytics, visualization, and neural experimentation.

Groggy 0.4.0

Groggy v0.4.0 Release Notes

Release Date: September 1, 2025
Type: MAJOR RELEASE - Complete Architecture Overhaul
Focus: GraphEntity Foundation + Unified Traits System

🚨 BREAKING CHANGES - MAJOR RELEASE

This is a MAJOR RELEASE with significant architectural changes. While the public Python API remains largely compatible, the internal architecture has been completely redesigned.

🏗️ Complete Architecture Overhaul

✅ GraphEntity Foundation System

NEW: Introduced a universal trait system that unifies all graph entities under a common interface.

// New universal trait system
pub trait GraphEntity: std::fmt::Debug {
    fn entity_id(&self) -> EntityId;
    fn entity_type(&self) -> &'static str;
    fn graph_ref(&self) -> Rc<RefCell<Graph>>;
    // ... unified interface for all entities
}

Benefits:

• Universal Composability: All entities (nodes, edges, subgraphs, neighborhoods, components) share the same interface
• Zero Duplication: Traits are pure interfaces leveraging existing optimized storage
• Performance First: Direct references to existing efficient data structures
• Infinite Composability: Every entity can be filtered, queried, and transformed consistently

✅ Complete Traits System (2,087+ lines)

NEW: Eight specialized operation traits providing comprehensive functionality:

• GraphEntity: Universal foundation trait (201 lines)
• SubgraphOperations: Complete subgraph operations (642 lines)
• NodeOperations: Node-specific operations (328 lines)
• EdgeOperations: Edge-specific operations (258 lines)
• NeighborhoodOperations: Neighborhood analysis (209 lines)
• FilterOperations: Advanced filtering capabilities (320 lines)
• ComponentOperations: Connected components (107 lines)

✅ New Core Entity Types

NEW: Comprehensive entity system with specialized types:

• Node: Individual node wrapper with trait implementation (334 lines)
• Edge: Individual edge wrapper with trait implementation (215 lines)
• ComponentSubgraph: Connected components subgraph (567 lines)
• FilteredSubgraph: Advanced filtering subgraph (690 lines)
• HierarchicalSubgraph: Multi-level analysis (652 lines)

✅ Enhanced Query System

NEW: Complete query parser and execution engine:

• Query Parser: Full SQL-like syntax support (674 lines)
• Enhanced Query Engine: Advanced graph queries with filtering
• Hierarchical Operations: Multi-level aggregation and analysis

🚀 Major Feature Enhancements

✅ Fixed Critical Subgraph Operations

BREAKING FIX: Resolved all subgraph traversal operations that were previously broken:

# These operations now work correctly
bfs_result = subgraph.bfs(start_node, max_depth)         # ✅ Fixed
dfs_result = subgraph.dfs(start_node, max_depth)         # ✅ Fixed  
shortest_path = subgraph.shortest_path_subgraph(s, t)    # ✅ Fixed
induced_sg = subgraph.induced_subgraph(node_list)       # ✅ Fixed
edge_sg = subgraph.subgraph_from_edges(edge_list)       # ✅ Fixed

Technical Fix: Resolved trait object conversion in FFI layer while maintaining clean architecture.

✅ New Connectivity Analysis

NEW: Added efficient path analysis capabilities:

# New connectivity methods
path_exists = subgraph.has_path(node1, node2)  # O(V+E) BFS-based
components = graph.connected_components()       # 4.5x performance improvement
neighborhoods = graph.neighborhood_sampling()   # Complete neighborhood analysis

✅ Enhanced FFI Architecture

IMPROVED: Complete FFI layer redesign with modular structure:

• Modular Organization: Separated concerns across specialized modules
• Pure Delegation: FFI layer delegates to core Rust implementations
• Memory Safety: Improved reference management and error handling
• Performance: Reduced overhead through direct core access

📊 Performance Improvements

Connected Components Algorithm

• 4.5x speedup through algorithmic optimization
• Improved memory efficiency with sparse representation
• Better cache utilization patterns

Neighborhood Sampling

• Complete implementation of neighborhood sampling functionality
• Efficient bulk operations for large-scale analysis
• Optimized attribute access patterns

Query Processing

• Native query parser replacing Python-based implementation
• Improved query execution performance
• Better error handling and validation

🔧 Technical Implementation Details

Architecture Patterns

1. GraphEntity Foundation

// Universal entity access
trait GraphEntity {
    fn get_attribute(&self, name: &AttrName) -> GraphResult<Option<AttrValue>>;
    fn set_attribute(&self, name: AttrName, value: AttrValue) -> GraphResult<()>;
    fn is_active(&self) -> bool;
    fn related_entities(&self) -> GraphResult<Vec<Box<dyn GraphEntity>>>;
}

2. Specialized Operations

// Each entity type has specialized operations
trait SubgraphOperations: GraphEntity {
    fn node_set(&self) -> &HashSet<NodeId>;
    fn edge_set(&self) -> &HashSet<EdgeId>;
    fn bfs(&self, start: NodeId, max_depth: Option<usize>) -> GraphResult<Box<dyn SubgraphOperations>>;
    // ... comprehensive subgraph operations
}

3. FFI Conversion Pattern

// Consistent trait object -> concrete type conversion
match self.inner.operation() {
    Ok(trait_object) => {
        let concrete = ConcreteType::new(
            self.inner.graph_ref(),
            trait_object.node_set().clone(),
            trait_object.edge_set().clone(),
            operation_name,
        );
        Ok(PyWrapper { inner: concrete })
    }
}

📋 Migration Guide

For Python Users

Most Python code continues to work unchanged:

# Existing code still works
g = groggy.Graph()
g.add_node("alice", age=30)
g.add_edge("alice", "bob") 
subgraph = g.subgraph()

# Previously broken operations now work
bfs_result = subgraph.bfs("alice")  # ✅ Now works

New capabilities available:

# New functionality
path_exists = subgraph.has_path("alice", "bob")
components = g.connected_components()
neighborhoods = g.neighborhood_sampling(["alice"], max_depth=2)

For Rust Users

Breaking changes in internal APIs:

• Entity types now implement GraphEntity trait
• Specialized operation traits for different entity types
• Enhanced error handling with GraphResult<T>
• New entity ID system with EntityId enum

🚨 Breaking Changes

Internal API Changes

• Rust internal APIs: Complete redesign of trait system
• Entity identification: New EntityId system replaces simple IDs
• Error types: Enhanced GraphError with better context
• Memory management: Improved reference counting patterns

Python Compatibility

• ✅ Public Python API: Largely unchanged, existing code should work
• ✅ Core operations: All graph operations maintain same interface
• ✅ Data access: Attribute access patterns unchanged
• 🔄 Advanced features: Some internal debugging/inspection APIs may have changed

📦 Installation

From Source

git clone https://github.com/rollingstorms/groggy.git
cd groggy/python-groggy
pip install maturin
maturin develop --release

Verify Installation

import groggy as gr

# Test the major improvements
g = gr.Graph()
g.add_nodes([
    {"id": "alice", "age": 30, "dept": "eng"},
    {"id": "bob", "age": 25, "dept": "design"}, 
    {"id": "charlie", "age": 35, "dept": "eng"}
])
g.add_edges([
    ("alice", "bob", {"weight": 0.8}),
    ("bob", "charlie", {"weight": 0.6})
])

# Test fixed subgraph operations
subgraph = g.subgraph()
print(f"✅ BFS from alice: {subgraph.bfs('alice').node_count()} nodes")
print(f"✅ Path alice->charlie: {subgraph.has_path('alice', 'charlie')}")

# Test new functionality
components = g.connected_components()
print(f"✅ Connected components: {len(components)}")

print("🎉 Groggy v0.4.0 - Complete architecture overhaul successful!")

📊 Development Statistics

Files changed: 112
Lines added: 45,220
Lines removed: 4,074
Net addition: 41,146 lines

New core files: 15+
New trait implementations: 8
New entity types: 5
New FFI modules: 8
Documentation added: 15,000+ lines

🎯 Next Release (v0.5.0)

With the new architecture foundation in place:

• Visualization Module: Interactive and static graph visualization
• Advanced Linear Algebra: Matrix decompositions with new traits system
• Performance Optimizations: SIMD operations leveraging unified architecture
• Machine Learning Integration: Graph neural networks using GraphEntity system
• Distributed Computing: Multi-node processing with trait-based entities

🙏 Acknowledgments

This release represents a fundamental transformation of Groggy's architecture while maintaining user-facing compatibility. The new GraphEntity foundation provides infinite composability and sets the stage for advanced features in future releases.

Key Achievement: Complete internal architecture overhaul that:

• Fixes critical functionality that was completely broken
• Introduces a powerful, extensible trait system
• Maintains Python API compatibility
• Provides foundation for advanced future features
• Delivers significant performance improvements

The 45,000+ lines of new code establish Groggy as a serious, enterprise-ready graph analytics platform built on solid architectural principles.

---

Full Changelog: v0.3.0...v0.4.0
Documentation: https://groggy.readthedocs.i...

Groggy v0.3.0

Groggy v0.3.0 Release Notes

Release Date: August 2025
Major Feature: Complete rewrite from the ground up

🎉 Overview

Groggy v0.3.0 represents a complete rewrite from the ground up. This release transforms Groggy into a unified graph analytics platform that seamlessly bridges graph topology and advanced tabular operations through three core storage views: Arrays, Matrices, and Tables.

🚀 Major Features

Unified Storage Architecture

Three-tier storage system providing seamless data access:

• GraphArray: High-performance columnar arrays with native statistical operations
• GraphMatrix: Homogeneous matrix operations with linear algebra support
• GraphTable: Pandas-like tabular operations with graph integration
• Lazy Evaluation: Memory-efficient views with on-demand computation

Advanced Analytics Suite

Complete statistical and relational operations:

• Multi-Table Operations: JOIN (inner, left, right, outer), UNION, INTERSECT
• GROUP BY & Aggregation: 10+ statistical functions (sum, count, mean, min, max, std, var, first, last, unique)
• Graph-Aware Operations: Neighborhood analysis, k-hop traversal, connectivity filtering
• Statistical Computing: Comprehensive descriptive statistics with intelligent caching

High-Performance Computing

Native Rust performance with Python ergonomics:

• Columnar Storage: Memory-efficient attribute pools with string/float/byte reuse
• Smart Caching: Intelligent cache invalidation for statistical computations
• Batch Operations: Vectorized operations for large-scale processing
• Zero-Copy Views: Efficient data access without unnecessary copying

Intuitive Python API

Intuitive, pandas-compatible API:

• Familiar Methods: .head(), .tail(), .describe(), .group_by()
• Rich Display: Beautiful HTML tables and formatted output in Jupyter
• Advanced Indexing: Support for slicing, boolean masks, fancy indexing
• Seamless Conversion: Easy export to pandas, NumPy, CSV, JSON

📊 Performance Achievements

48x Performance Improvement

• Critical Breakthrough: Node filtering optimized from 2,054ns to 213ns per node
• Root Cause Fixed: Bottleneck was in Python binding layer, changed to direct find_nodes() calls
• Production Ready: Node filtering now competitive at 13.6x slower than edges (was 68x slower)

Competitive Performance vs NetworkX

• Graph Creation: 2.0x faster than NetworkX
• Filter Numeric Range: 1.4x faster
• Filter Edges: 3.6x faster
• BFS Traversal: 11.5x faster
• Connected Components: 9.0x faster

Excellent O(n) Scaling

Per-Item Performance Scaling (50K → 250K nodes):
✅ Numeric Range Filtering: 74→83ns (Excellent O(n))
✅ Filter NOT Operations: 141→124ns (Excellent O(n))  
✅ Connected Components: 348→355ns (Excellent O(n))
⚠️ Single Attribute: 84→109ns (Good ~O(n log n))
⚠️ Complex AND: 92→134ns (Good ~O(n log n))

🏗️ Architecture Improvements

Core Rust Implementation

• Unified Core: All storage views implemented in src/core/ with consistent architecture
• Memory Management: Sophisticated AttributeMemoryPool with efficient buffer reuse
• Type Safety: Comprehensive error handling across Python-Rust boundary
• FFI Layer: Clean separation between core functionality and Python bindings

Python FFI Layer

• Complete Bindings: Full coverage of core functionality in python-groggy/src/ffi/
• Error Translation: User-friendly Python exceptions from Rust errors
• Memory Safety: Safe reference management preventing memory leaks
• Display Integration: Rich HTML output for Jupyter notebooks

🔧 API Enhancements

GraphArray (Renamed from PyArray)

• API Consistency: Better naming scheme across the library
• Native Statistical Operations: All statistics computed in Rust with lazy caching
• GraphTable Integration: Table columns automatically return GraphArray objects
• List Compatibility: Full drop-in replacement (len, indexing, iteration)

Enhanced Query Parser

• Complex Logic: 3+ term expressions with AND/OR operations
• Parentheses Support: Proper grouping and operator precedence
• Boolean Parsing: true/false correctly mapped to values
• NOT Operations: Support for NOT with complex expressions

Multi-Column Slicing

• DataFrame-like Access: Multi-column data access directly on graph slices
• Backward Compatible: Single string access still works
• 2D Structure: Returns column-wise data efficiently

Subgraph API Consistency

• Property Access: subgraph.node_ids and subgraph.edge_ids now work consistently
• Connected Components: Components now include all internal edges correctly
• Consistent Behavior: Subgraph API matches PyGraph for basic properties

⚠️ Known Limitations

Temporary Placeholders

• PyGraphMatrix.is_symmetric(): Returns false, needs core implementation
• Matrix/Sparse adjacency methods: Temporarily disabled pending sparse matrix implementation
• Some iterator methods: Temporarily disabled for compilation stability

Future Enhancements (v0.4.0+)

• Advanced Linear Algebra: Matrix multiplication, decompositions, BLAS integration
• Sparse Matrix Optimization: Full sparse matrix support with SciPy integration
• Visualization Module: Interactive and static graph visualization
• Performance: SIMD optimizations, parallel processing, GPU acceleration

🔄 Migration Guide

Upgrading from v0.2.x

This is a complete rewrite, so migration will require updating your code. The main changes:

• Storage Views: Graph data is now accessed through GraphArray, GraphMatrix, and GraphTable views
• Performance: Significant speed improvements across all operations
• API: More consistent and pandas-compatible interface
• Statistical Operations: Native Rust statistical functions available on all data structures

📦 Installation

From Source (Current)

git clone https://github.com/rollingstorms/groggy.git
cd groggy
pip install maturin networkx
cd python-groggy
maturin develop --release

Verify Installation

import groggy
print(f"Groggy v0.3.0 installed successfully")

🎯 Roadmap

Next Release (v0.4.0) - Visualization & Advanced Linear Algebra

• Interactive Visualization: Web-based graph visualization
• Static Visualization: Publication-quality graph output
• Advanced Linear Algebra: Matrix multiplication, SVD, QR decomposition
• NumPy Integration: Performance-optimized NumPy backend for matrix operations

Future Releases

• Enterprise Features: Arrow/Parquet integration, distributed computing
• Advanced Analytics: Machine learning integration, graph neural networks
• Cloud Integration: Deployment tools and cloud-native features

🙏 Acknowledgments

This release represents a complete architectural overhaul, providing a solid foundation for advanced graph analytics. The unified storage views enable powerful new workflows that seamlessly combine graph topology with statistical analysis.

Key architectural achievements:

• Unified Storage Views: Seamless integration between graph and tabular data
• Performance Excellence: Native Rust computation with Python ergonomics
• Memory Efficiency: Columnar storage with intelligent caching
• Developer Experience: Intuitive APIs with comprehensive documentation

---

Full Changelog: v0.2.0...v0.3.0
Documentation: https://groggy.readthedocs.io
Issues: https://github.com/rollingstorms/groggy/issues

Groggy v0.2.1 - Alpha Demo Release

🧪 Groggy v0.2.1 - Alpha Demo Release

⚠️ Alpha Software: This is an early demo release for testing and feedback. The API may change and there may be bugs or incomplete features.

What's New in v0.2.1

• Simplified Rust crate naming (renamed from groggy-core to groggy)
• Basic graph operations with node/edge management
• Simple filtering capabilities
• Cross-platform builds (Linux, macOS, Windows)
• Python 3.8-3.12 support

🚀 Try It Out

bash
pip install groggy

example:

import groggy as gr

# Create a simple graph
g = gr.Graph()
g.add_node("alice", age=30)
g.add_node("bob", age=25)
g.add_edge("alice", "bob", relationship="friend")

# Basic filtering
young_people = g.filter_nodes('age < 30')

📝 Feedback Welcome

This is my first public Python/Rust project! If you try it out, I'd love to hear:

What works well
What's confusing or broken
Ideas for improvements
Please open issues or discussions on GitHub - all feedback is appreciated!

🔧 Current Limitations

Limited documentation
Basic feature set
API may change in future versions
Performance not yet fully optimized
Thanks for checking out Groggy! 🐸