cells

Future-proof content collaboration platform

1,803

179

1,803

View on GitHub

Top Related Projects

core

8,364

:cloud: ownCloud web server core (Files, DAV, etc.)

server

27,149

☁️ Nextcloud server, a safe home for all your data

syncthing

64,580

Open Source Continuous File Synchronization

Heimdall

7,689

An Application dashboard and launcher

Quick Overview

Pydio Cells is an open-source, enterprise-grade file sharing and synchronization platform. It offers a modern, scalable solution for organizations to securely manage and share their data, providing features like access control, versioning, and collaboration tools.

Pros

Highly scalable and designed for enterprise use
Advanced security features, including end-to-end encryption
Flexible deployment options (on-premises, cloud, or hybrid)
Rich set of APIs for integration and customization

Cons

Steeper learning curve compared to some simpler file-sharing solutions
Requires more resources to set up and maintain than basic alternatives
Some advanced features may require a paid license
Documentation could be more comprehensive for certain advanced topics

Getting Started

To get started with Pydio Cells, follow these steps:

Download the latest release from the official website.
Extract the archive and navigate to the extracted directory.
Run the installation script:

./cells install

Follow the prompts to configure your installation.
Once installed, start Pydio Cells:

./cells start

Access the web interface by navigating to http://localhost:8080 in your browser.

For more detailed instructions and configuration options, refer to the official documentation.

Competitor Comparisons

core

8,364

:cloud: ownCloud web server core (Files, DAV, etc.)

Pros of ownCloud

Larger community and more extensive ecosystem of apps and integrations
Longer history and more mature codebase with proven stability
Better documentation and user guides for easier setup and maintenance

Cons of ownCloud

Heavier resource usage, especially for larger deployments
Less modern architecture, making it potentially slower in some scenarios
More complex upgrade process due to its longer history and legacy support

Code Comparison

ownCloud (PHP):

<?php
namespace OCA\Files\Controller;

use OCP\AppFramework\Controller;
use OCP\IRequest;

class ViewController extends Controller {
    public function __construct($appName, IRequest $request) {
        parent::__construct($appName, $request);
    }
}

Cells (Go):

package cells

import (
    "context"
    "github.com/pydio/cells/common"
)

type ViewController struct {
    common.AbstractHandler
}

func (v *ViewController) Handle(ctx context.Context) error {
    // Implementation
}

Both projects use MVC-like patterns, but Cells leverages Go's concurrency features and has a more modern, microservices-oriented architecture. ownCloud's PHP codebase is more traditional and may be easier for PHP developers to understand and contribute to.

server

27,149

☁️ Nextcloud server, a safe home for all your data

Pros of Nextcloud

Larger and more active community, with more frequent updates and contributions
Extensive ecosystem of apps and integrations
More comprehensive documentation and user guides

Cons of Nextcloud

Can be resource-intensive, especially for larger deployments
More complex setup and configuration process
Potential security risks due to its larger attack surface

Code Comparison

Nextcloud (PHP):

<?php
namespace OCA\Files\Controller;

use OCP\AppFramework\Controller;
use OCP\IRequest;

class ViewController extends Controller {
    public function __construct($appName, IRequest $request) {
        parent::__construct($appName, $request);
    }
}

Cells (Go):

package cells

import (
    "context"
    "github.com/pydio/cells/common"
    "github.com/pydio/cells/common/proto/tree"
)

type Handler struct {
    ctx context.Context
}

func (h *Handler) ReadNode(ctx context.Context, req *tree.ReadNodeRequest) (*tree.ReadNodeResponse, error) {
    // Implementation
}

The code snippets showcase the different programming languages used (PHP for Nextcloud, Go for Cells) and highlight the contrasting approaches to handling requests and implementing core functionality. Nextcloud's code is more object-oriented, while Cells uses a more functional approach with Go's concurrency features.

syncthing

64,580

Open Source Continuous File Synchronization

Pros of Syncthing

Decentralized and peer-to-peer architecture, offering better privacy and control
Lightweight and efficient, suitable for various devices including mobile
Open-source with a large community and active development

Cons of Syncthing

Lacks built-in user management and access control features
No web-based interface for file management
Limited collaboration tools compared to Cells

Code Comparison

Syncthing (Go):

func (m *Model) Index(deviceID protocol.DeviceID, folder string, files []protocol.FileInfo) {
    m.fmut.Lock()
    defer m.fmut.Unlock()

    m.folderFiles[folder] = append(m.folderFiles[folder], files...)
}

Cells (Go):

func (s *TreeService) CreateNode(ctx context.Context, request *tree.CreateNodeRequest, opts ...client.CallOption) (*tree.Node, error) {
    node := &tree.Node{
        Path: request.Node.Path,
        Type: request.Node.Type,
    }
    return s.clientsPool.CreateNode(ctx, node, opts...)
}

Both projects use Go, but Cells focuses on a more structured approach with gRPC-style services, while Syncthing emphasizes efficient file synchronization algorithms.

code-server

68,066

VS Code in the browser

Pros of code-server

Browser-based VS Code environment, enabling remote development from any device
Supports a wide range of VS Code extensions, enhancing functionality
Easy to set up and use, with straightforward installation process

Cons of code-server

Requires more server resources due to running a full VS Code instance
May have latency issues when used over slow internet connections
Limited built-in file management and collaboration features compared to Cells

Code comparison

code-server (JavaScript):

app.post('/api/login', async (req, res) => {
  const { password } = req.body
  if (password === process.env.PASSWORD) {
    res.json({ token: generateToken() })
  } else {
    res.status(401).send('Unauthorized')
  }
})

Cells (Go):

func (h *Handler) Login(w http.ResponseWriter, r *http.Request) {
    var creds Credentials
    if err := json.NewDecoder(r.Body).Decode(&creds); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    // Authentication logic here
}

Both projects serve different purposes: code-server focuses on providing a remote development environment, while Cells is a comprehensive file management and collaboration platform. code-server excels in offering a familiar VS Code experience in the browser, making it ideal for developers who need remote access to their development environment. Cells, on the other hand, provides a more robust set of features for file management, sharing, and team collaboration, making it suitable for organizations looking for a complete content management solution.

Heimdall

7,689

An Application dashboard and launcher

Pros of Heimdall

Lightweight and easy to set up as a dashboard for self-hosted services
Supports a wide range of application icons and custom backgrounds
Actively maintained with frequent updates and community support

Cons of Heimdall

Limited functionality compared to Cells' comprehensive file management features
Lacks advanced user management and access control options
No built-in file sharing or collaboration tools

Code Comparison

Heimdall (Docker-compose.yml):

version: "2.1"
services:
  heimdall:
    image: lscr.io/linuxserver/heimdall:latest
    container_name: heimdall
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/London

Cells (Docker-compose.yml):

version: '3'
services:
  cells:
    image: pydio/cells:latest
    ports:
      - "8080:8080"
    volumes:
      - ./data:/var/cells
    environment:
      - CELLS_EXTERNAL_URL=http://localhost:8080

Heimdall is primarily a dashboard for organizing and accessing self-hosted services, while Cells is a comprehensive file management and collaboration platform. Heimdall offers a simpler setup and lightweight interface, but lacks the advanced features and file management capabilities of Cells. The code comparison shows that both projects can be easily deployed using Docker, with Cells requiring additional configuration for its more complex functionality.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Homepage | Dev Guide | GitHub-Repository | Issue-Tracker

Pydio Cells is the nextgen file sharing platform for organizations. It is a full rewrite of the Pydio project using the Go language following a micro-service architecture.

Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See the Deployment section below for notes on how to deploy the project on a live system.

A - Prerequisites

The following elements are required to compile and run Pydio Cells on your machine:

Go language v1.21 or higher and a correctly configured Go toolchain,
MySQL database 5.6 or higher (or MariaDB equivalent).

Note: We have developed and tested Pydio Cells on macOS, Ubuntu, Debian and CentOS. Windows version might still have unknown glitches and is not yet supported.

B - Build From Sources

Assuming that your system meets the above prerequisites, building the Pydio Cells backend from the source code is quite straightforward:

# Retrieve the code
git clone https://github.com/pydio/cells
# Enter cells directory
cd cells
# Build your binary
make dev

C - Configure Environment

To have the environment running, you must also:

Create a database in your chosen DB server,
Run the Pydio Cells installer that will guide you through the necessary steps: you might refer to the official documentation for additional information.

./cells configure

D - Start Server

./cells start

Access the default site https://localhost:8080/ and you are good to go. Learn more about Cells features and advanced configuration in the Documentation.

Running the tests

To run the tests, simply do

go test -v ./...

Please read the CONTRIBUTING.md document if you wish to add more tests or contribute to the code.

Pre-built Binaries

Binaries are currently provided for Linux, macOS and Windows distributions. To deploy them on a live system, please see the Installation Guide instructions.

Contributing

Please read CONTRIBUTING.md for details on our code of conduct, and the process for submitting pull requests to us. You can find a comprehensive Developer Guide on our website. Our online docs are open-source as well, feel free to improve them by contributing!

We are also looking for help to translate the Cells interface in various languages. It is really easy to participate: just navigate to our page in the Crowdin translation tool, create an account and get started.

Pydio Cells uses many open-source libraries. The most important ones are listed below, please see DEPENDENCIES for an exhaustive list of other libs and their licenses.

Versioning & Branches

Please note that git main branch moved from master for Cells v1 to v3 (vendoring, no modules) to main for Cells v4 (go modules).

We use Semantic Versioning. For all available versions, see the release list.

Authors

See the list of contributors who participated in this project. Pydio Cells is also a continuation of the Pydio project and many contributions were ported from pydio-core to the code that can be found under frontend/front-srv/assets.

License

This project is licensed under the AGPLv3 License - see the LICENSE file for more details.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot