Gsoc 2026 Reference Implementation for concore Library in Julia.

[GaneshPatil7517]

Hey @pradeeban @Rahuljagwani @mayureshkothare
Understanding of the Project
I have thoroughly explored the concore repository and understand that it is a lightweight framework designed for closed-loop peripheral neuromodulation control systems. The framework enables communication between different components (controllers, plant models, observers) through a file-based inter-process communication mechanism.

Key observations from my code review:

Core Functions: The library provides essential functions like:

• concore_read() / concore_write() - for reading/writing port data
• concore_iport() / concore_oport() - for port initialization
• concore_initval() - for setting initial values
• concore_default_maxtime() - for timeout configuration

Existing Implementations: concore currently supports:

• Python (concore.py) - Primary reference implementation
• C++ (concore.hpp) - Header-only implementation
• MATLAB/Octave (.m files) - Multiple function files
• Verilog (concore.v) - Hardware description support
• Architecture: The framework uses a directory-based communication model where each port creates a subdirectory, and data is exchanged via files with retval/simtime tracking for synchronization.

Docker Support: The concoredocker.* variants provide containerized execution capabilities.

Proposed Approach for Julia Implementation
I plan to create a complete, idiomatic Julia implementation that mirrors the Python reference while leveraging Julia's unique strengths:

Phase 1: Core Module Development (Weeks 1-4)

Implement Concore.jl module with all core functions
Create Julia-native file I/O operations with proper error handling
Implement the retval/simtime synchronization mechanism
Design type-safe port data structures using Julia's type system

Phase 2: Enhanced Features (Weeks 5-8)
Implement ConcoredDocker.jl for container support
Add comprehensive logging and debugging utilities
Create Julia-specific optimizations (using multiple dispatch, macros where appropriate)
Ensure thread-safety for concurrent operations

Phase 3: Testing & Documentation (Weeks 9-11)
Port existing Python examples to Julia
Create comprehensive unit tests using Julia's Test standard library
Write detailed documentation with Documenter.jl
Performance benchmarking against Python implementation

Phase 4: Integration & Polish (Week 12)
Integration testing with existing concore ecosystem
Code review incorporation and final refinements
Create tutorial notebooks demonstrating Julia usage
Package registration preparation for Julia General Registry

module Concore

export concore_read, concore_write, concore_iport, concore_oport, concore_initval

mutable struct ConcoreState
simtime::Float64
retval::Int
iport::Dict{String, String}
oport::Dict{String, String}
initval::Dict{String, Any}
maxtime::Float64
verbose::Bool
end

const concore = ConcoreState(0.0, 1, Dict(), Dict(), Dict(), 50.0, false)

function concore_read(portname::String, maxtime::Float64=concore.maxtime)
# Implementation following Python reference
# File-based synchronization with retval checking
end

function concore_write(portname::String, data::Any, delta::Float64=1.0)
# Write data to port file with simtime update
end

end # module

Current Progress

I have already drafted a proposal that is approximately 90% complete, covering:

Detailed timeline with weekly milestones
Technical architecture and design decisions
Risk assessment and mitigation strategies
Testing and validation methodology

I would be grateful to share this draft with you in the next 2 days for your valuable feedback before the official submission deadline. Your insights would help me refine my approach and ensure alignment with the project's vision.

Questions for Mentors
I would appreciate your guidance on the following:

API Consistency: Should the Julia implementation strictly mirror the Python API, or are there Julia-specific improvements you'd welcome?

Priority Features: Are there any specific features or use cases that should be prioritized in the Julia implementation?

Integration Testing: What existing examples/demos would you recommend I focus on for end-to-end testing?

Package Distribution: Do you have preferences for how the Julia package should be distributed (Julia General Registry, project-specific registry, or direct GitHub installation)?

Performance Considerations: Are there any performance-critical sections where Julia's speed advantages should be specifically leveraged?

[GaneshPatil7517]

hello @pradeeban sir my praposal is ready were i can share that with you........?