Lipupini is a public domain platform for organizing and displaying digital art such as images, videos, sounds and writings that you might want to display under your domain on the Internet. Lipupini aims to support RSS and Fediverse protocols.

Status

Features

Lipupini Docker Setup

Starting Lipupini with PHP

Add Your Collection

ActivityPub Note

The Name

Demo

Contributing

Acknowledgements

For displaying a media portfolio or posts on the Internet, despite currently limited ActivityPub support the latest release of Lipupini is considered to be production-ready.

1. Install dependencies and clone the repository to the latest release tag. While the demo site has maintained the same respository since version 1.x, avoid using the demo branch in production unless you are interested in keeping up with development and have a mechanism for rollbacks.
2. Add and initialize your collection, customize .lipupini/files.json with captions, and delete the example collection.
3. Ensure that your files display. If they don't, convert them to supported formats.
4. Deploy to a PHP server.

Updating Lipupini can be as simple as running git pull from your environment depending on the setup.

• Collections are completely portable on the file system.
• There is no database needed. Metadata can optionally be stored in JSON files contained within collections.
• JavaScript can be disabled and the default frontend module will still display media.
• Media files are added via file transfer directly into the collection folder. Lots of apps can already be used for managing Lipupini collections.

• Support for the following media file formats: AVIF, FLAC, GIF, JPG, PNG, M4A, MP3, MP4, Markdown, OGG Vorbis
• Allows subscribing to your content collection via RSS2.0.
• Search Lipupini accounts from other Fediverse platforms via the ActivityPub protocol.
• Supports translations/internationalization: See src/Frontend/Languages
• Robust cross-browser E2E test suite
• Automatically fix image orientation and strip private metadata thanks to Imagine library
• With ffmpeg available and useFfmpeg enabled, video thumbnails and audio waveforms can be generated automatically.
• Supports both "hidden" and "unlisted" options in files.json
• Once dependencies are installed, Lipupini is designed to get up and running quickly.
• Media collections are self-contained, served as they are on your filesystem. Lipupini-specific collection files are stored in a special .lipupini folder, making account collections completely portable.
• Composer pattern paves a way for new request modules in packages.
• Docker support. See deployment instructions.
• Show an avatar image when searching from an external ActivityPub or RSS client.
• Lipupini manages to implement ActivityPub without a database. Certain inbox activities can be logged to your collection in raw JSON. See system/config/state.php for the option.
• Built-in JS/CSS cache busting mechanism. Increment system/config/state.php to bust that cache!
• Minimalist grid layout. Frontend is ready to be customized.
• On-demand caching system creates and serves static media files. Support for custom caching URL can facilitate the use of a CDN.
• Public domain source code is the most permissive license there is. You can do whatever you want with this thing. Please feel free to contribute back to upstream, post in discussions, etc. There is no obligation of any kind.

Make sure all dependencies are installed first.

1. Clone the app and cd into the project root

git clone https://github.com/lipupini/lipupini.git
cd lipupini

2. Install Composer dependencies. Composer should automatically create the config file after installing. See system/config/README.md

composer install

3. Navigate to the webserver document root and start PHP's built-in webserver

cd webroot
php -S localhost:4000 index.php

4. Visit http://localhost:4000/@example

Say you have a folder of awesome photos at /home/sally/Pictures/AwesomePhotos

Your Lipupini installation is at /opt/webapp/lipupini

1. Take the photos from /home/sally/Pictures/AwesomeCollection and put them into the collection directory /opt/webapp/lipupini/collection/sally either by copying them:

cp -R /home/sally/Pictures/AwesomeCollection /opt/webapp/lipupini/collection/sally

or symlinking them:

ln -s /home/sally/Pictures/AwesomeCollection /opt/webapp/lipupini/collection/sally

2. Initialize the .lipupini folder for the collection

cd /opt/webapp/lipupini
bin/generate-keys.php sally
bin/create-files-json.php sally

3. Save a file called avatar.png at /opt/webapp/lipupini/collection/sally/.lipupini/avatar.png

4. Edit the file at /opt/webapp/lipupini/collection/sally/.lipupini/files.json to add captions (this is optional)

5. Delete the example collection:

rm -r collection/example

6. Your collection should now be viewable at http://localhost:4000/@sally

In addition to copying or symlinking, see collection/README.md#vision for ideas on other ways to keep these directories in sync.

ActivityPub transactions should occur via HTTPS per spec. https://ngrok.com can be used to get up and running quickly for development.

For example, after starting Lipupini you can run this command:

ngrok http 4000

Continuing with the example above in "Add Your Collection," if your Ngrok URL becomes https://f674-73.ngrok-free.app, you should then be able to query @sally@f674-73.ngrok-free.app from another Fediverse client once the collection is initialized.

Using Ngrok, with an upgraded plan you can setup a fairly restrictive port firewall, configure it to run on startup, and reliably host any domain with HTTPS.

"Lipupini" is a word formed by combining other words (portmanteau), and "lipu pini" in this context translates to "past document" in Toki Pona core. Lipupini is for organizing computer files like images, videos, sounds and writings that you might want to display under your domain on the Internet.

Here is what it can look like so far: https://lipupini-demo.dup.bz/@example

Though ActivityPub implementation is currently limited, the demo is searchable in properly-configured Fediverse clients @example@lipupini-demo.dup.bz

NOTE: Please use activitypub.academy Mastondon server for testing, as this is a test server.

The demo is the demo branch running on Apache2. If you already have Apache2 configured to serve PHP, you can install Composer dependencies and point the virtual host's DocumentRoot to webroot and it should "just work."

You are welcome to fork it, change it, add modules! Please don't hesitate to make a PR.

Email apps [at] dup.bz if you'd like a point of contact or post in discussions! Please reach out if you begin to find any aspect frustrating or feel that it should be done in a different way.

If you want to use Lipupini for your artist portfolio or business website, I will support your effort.

VanJS: https://vanjs.org

Markdown parser: https://parsedown.org

Image processor: https://github.com/php-imagine/Imagine

Arrow icons: https://www.svgrepo.com/author/Pictogrammers

ActivityPub inspiration: @dansup@pixelfed.social & Landrok's ActivityPub library

• Add option for favicon in collection .lipupini folder
• bin/generate-files-json.php
  • Make recursive
  • Do not overwrite entries, or add option
  • Read EXIF data if available for setting a default date
• Something else besides exception when file in files.json does not exist in collection
• Test language switching mechanism
• Create script to normalize file and directory user/group/permissions
• Check on cross-platform compatibility, MacOS and Windows with and without Docker. While only tested on Linux, I believe it will work on all three OSes including ffmpeg interfaces as long as symlinking is supported.
• Look into:
  • https://indieweb.org/Webmention
  • https://indieweb.org/Microsub
  • https://indieweb.org/Micropub
  • https://atproto.com
  • https://micropub.rocks
• Detect readline support in a custom confirm routine. If readline is not available a 10-second timer will be indicated that can be cancelled with CTRL+C.
• Create a mechanism for writing to a collection's files.json
  • Could start with a CLI tool, e.g. bin/caption.php <collection> <filename> <caption>
  • Would like to try creating a desktop tool
• ActivitPub: Do not let same account try to follow more than once when already logged previous follow
• Look into caching headers
• If a photo is taking a while to upload and a browser pageload is triggered with media processor requests in the request queue, the thumbnail version will likely only show a partial image.
  • Removing all media processors from the HTTP request queue and only using bin/process-media.php after uploading is a solution.
  • File transfer clients that use temporary files during transfer are a solution.
  • Adding a file watcher daemon or transfer queue could help with an alternative solution.
  • I would like to know if there is a way using pure PHP to detect if a file is still uploading via SFTP.