Magiiic.org

Projects

  • Oli Prompt Tools

    A collection of practical ComfyUI utility nodes designed to reduce workflow complexity. Each node solves a specific recurring problem — avoiding VRAM crashes, picking prompts deterministically, filtering incompatible LoRAs, or labelling model pipelines. No external dependencies beyond the standard ComfyUI environment.

    Buy Me a Coffee ✨ Tip the Wizard GitHub Sponsors

    Nodes

    Node Category Purpose
    Mega Lora Loader Oli/loaders Stackable multi-LoRA loader with automatic compatibility filtering
    Mega String List Oli/prompt Collects strings and lists from multiple sources into a unified list
    Prompt Line Pick Oli/prompt Seed-driven line picker — uniform distribution, fully independent instances
    Video Frame Limit Oli/utils Caps video duration to avoid VRAM out-of-memory crashes
    Model Info Oli/utils Returns architecture details of any connected model
    Node Label Oli/utils Reads and passes through the upstream node’s title

    Installation

    Via ComfyUI Manager (recommended): search for Oli Prompt Tools and click Install.

    Manually:

    cd ComfyUI/custom_nodes
git clone https://github.com/magicoli/oli-prompt-tools

    Restart ComfyUI. No additional dependencies required.

    Mega Lora Loader (Oli)

    Stackable multi-LoRA loader inspired by rgthree’s Power Lora Loader. Key additions: stackable, and each LoRA’s safetensors header is checked against the connected model’s key map before loading — incompatible LoRAs are silently skipped rather than producing errors or corrupted output.

    • Add as many LoRA rows as needed with the ➕ Add LoRA button.
    • Each row has an on/off toggle, a LoRA selector, and a strength slider.
    • Incompatible LoRAs are highlighted in the UI (orange = incompatible, grey = disabled).
    • Connect the enable input to a boolean condition to bypass all LoRAs at once — useful with switch or router nodes.
    • Two usage modes: connect model/clip to apply LoRAs immediately, or leave them unconnected to only build a LORA_STACK without applying it. In stack-only mode the node acts as a LoRA definition block — chain several together, then feed the final stack to a downstream loader that has model/clip connected. This lets you define LoRAs once and apply them to multiple models at different points in the workflow.

    Mega Lora Loader example screenshot Mega Lora Loader example workflow

    Inputs

    Input Type Default Description
    lora_stack LORA_STACK — Incoming stack from another loader (optional)
    model MODEL — Model to apply LoRAs to (optional)
    clip CLIP — CLIP encoder to apply LoRAs to (optional)
    (lora rows) — — Added dynamically via the ➕ button
    enable BOOLEAN true When false, passes model/clip/lora_stack through unchanged

    Outputs

    Output Type Description
    lora_stack LORA_STACK Full stack including upstream entries
    MODEL MODEL Model with all compatible LoRAs applied
    CLIP CLIP CLIP with all compatible LoRAs applied

    Mega String List (Oli)

    Collects strings and lists from multiple sources into a single unified list. Each row can hold either typed text or a connected node output (STRING, LIST, or any type) — no separate input slots needed for typed vs. connected content. Rows can be individually toggled on/off, reordered by drag, or deleted. Lists from connected nodes are automatically expanded before addition.

    • Mixed sources — combine typed strings, node outputs, and upstream prompt lists in any order in a single node.
    • Drag to reorder — grab the ≡ handle to change the order of rows; the final list follows the visual order.
    • Per-row toggle — disable individual rows without deleting them using the pill switch.
    • Chainable — wire optional_prompt_list from a Prompt Line Pick or another Mega String List; the incoming list is prepended to the result.
    • Pass-through mode — when enable is set to False (labelled pass-through), the node returns only optional_prompt_list unchanged and ignores all rows. Useful for temporarily disabling additions or for conditional branching.
    • Delimiter — used both to split typed multi-value text into separate items, and to join all items into the string output. Supports escape sequences (n, t, …).
    • Items equal to "none" (case-insensitive) are automatically removed — SDXL Prompt Styler’s empty/ignore sentinel.

    Mega String List example screenshot Mega String List example workflow

    Inputs

    Input Type Default Description
    optional_prompt_list LIST — Accumulated list from an upstream node — prepended to the result (optional)
    enable BOOLEAN true When false (pass-through): return only optional_prompt_list, ignore all rows
    delimiter STRING , Splits typed text into items; also used to join the string output
    string 1-n * — Dynamic rows — type text directly or connect any node output; lists are expanded

    Outputs

    Output Type Description
    prompt_list LIST Combined list — wire to another Mega String List or Prompt Line Pick
    prompt_strings STRING (list) Same items as a STRING output list — compatible with easy promptList
    num_strings INT Number of items in the combined list
    string STRING All items joined by the delimiter

    Prompt Line Pick (Oli)

    Reimplementation of the easy promptLine concept. Replaces start_index with a seed. The picked index is derived via sha256(seed:node_id) % len(lines), giving a uniform distribution and full independence between instances: two pickers with the same seed pick at uncorrelated positions even when their lists have the same length or lengths that are multiples of each other. Output format is identical to easy promptLine — both STRING and COMBO return the list starting at the picked line.

    • Uniform distribution — every line has equal probability regardless of list length, with no correlation between lists of similar sizes.
    • Full independence — multiple instances in the same workflow each pick at independent positions, even with the same seed, because the node ID is part of the hash.
    • COMBO output is compatible with any COMBO-typed input (e.g. SDXL Prompt Styler artist/style fields): the picked line is always the first element.
    • Stackable — connect optional_prompt_list from a previous picker; this node appends its pick and passes the extended list through prompt_list. Chain as many pickers as needed, then feed into easy promptList or any string-join node.

    Prompt Line Pick example screenshot Prompt Line Pick example workflow

    Inputs

    Input Type Default Description
    prompt STRING — One item per line
    seed INT 0 Workflow seed — share with KSampler for reproducible pairs
    remove_empty_lines BOOLEAN true Strip blank lines before picking
    uncorrelate BOOLEAN true When on: index = sha256(seed:node_id) % len — independent between instances. When off: index = seed % len — same as easy promptLine’s start_index
    optional_prompt_list LIST — Accumulated list from an upstream picker (optional) — same type as easy promptList

    Outputs

    Output Type Description
    STRING STRING The single picked line (scalar)
    COMBO COMBO (list) The single picked line, compatible with COMBO-typed inputs (SDXL Prompt Styler etc.)
    prompt_list LIST Incoming list with this pick appended — wire to the next picker or to easy promptList
    prompt_strings STRING (list) All strings in the accumulated list — same format as easy promptList’s prompt_strings
    seed INT Pass-through — wire to the next picker without routing back

    Video Frame Limit (Oli)

    Caps video generation duration to avoid VRAM out-of-memory crashes. The frame budget is derived from transformer peak memory first principles rather than empirical constants:

    bytes_per_latent_frame = TENSOR_COPIES × (width÷8) × (height÷8) × hidden_dim × 2
max_frames             = total_vram × safety_margin ÷ bytes_per_latent_frame

    Where TENSOR_COPIES = 5 (Q, K, V, attention output, residual activations) and hidden_dim is auto-detected from the connected model. Uses total VRAM rather than free VRAM — ComfyUI offloads weights layer-by-layer, so peak activation memory scales with total VRAM, not the remainder after model loading.

    The node displays detected VRAM, model name, hidden dim, requested and capped frames directly on the canvas after each execution — making it usable as a standalone config panel for the whole generation.

    Video Frame Limit example screenshot Video Frame Limit example workflow

    Inputs

    Input Type Default Description
    width INT 832 Generation width in pixels
    height INT 480 Generation height in pixels
    fps FLOAT 16 Frames per second
    duration FLOAT 10 Requested duration in seconds
    safety_margin FLOAT 0.95 Fraction of total VRAM to budget (0.95 = 5% headroom)
    model MODEL — Optional — enables hidden_dim auto-detection

    Outputs

    Output Type Description
    width INT Pass-through
    height INT Pass-through
    frames INT Capped frame count
    fps FLOAT Pass-through
    duration FLOAT Actual duration after capping

    Model Info (Oli)

    Returns architecture details of any connected model (MODEL, CLIP, VAE, or any other type). Also reads the upstream node’s title. Useful for debugging model pipelines, inspecting what arrived on a bus, or driving conditional logic based on model class.

    Model Info example screenshot Model Info example workflow

    Inputs

    Input Type Description
    model * Any model type (optional)

    Outputs

    Output Type Description
    class_name STRING Python class name of the model (e.g. WAN21, Flux)
    dim INT Hidden dimension auto-detected from the model
    label STRING Title of the upstream node that produced the model

    Node Label (Oli)

    Passes any value through and outputs the title of the upstream node at a configurable traversal depth. Useful for labelling outputs, routing between branches, or building self-documenting workflows where node titles carry semantic meaning.

    Node Label example screenshot Node Label example workflow

    Inputs

    Input Type Default Description
    depth INT 1 Hops to travel upstream (1 = direct parent, 2 = grandparent…)
    node * — Any value — passed through unchanged (optional)

    Outputs

    Output Type Description
    node * Pass-through of the input value
    label STRING Title of the node depth hops upstream

    License

    GNU Affero General Public License v3.0

  • WooCommerce Virtual Less Fields

    Remove address fields on WooCommerce checkout page for orders with only virtual products.

    Ignores products identified as domain names with WooCommerce Domain Names plugin.

  • OpenSimulator REST PHP library and command-line client

    Version 1.0.6 Stable 1.0.6 Requires PHP 7.4 License AGPLv3

    This library allows to communicate with Robust or OpenSimulator instance with rest console enabled.

    It can be used inside a PHP project, or as a command-line client for OpenSimulator grids.

    Available commands can be found here: http://opensimulator.org/wiki/Server_Commands

    Prerequisites

    Remote connection must be enabled in your Robust .ini file.

    Do not leave default values!. You should never need to type username and password manually, so you can safely generate long random strings.

    You must choose a specific port, not already used by another service. It is good practice to limit access to this port to authorized IP addresses only in your firewall settings.

    [Network]
  ConsoleUser = arandomgeneratedstring
  ConsolePass = anotherrandomgeneratedstring
  ConsolePort = 8009
  ; choose a port not already used by another service

    Building

    Requires PHP with phar.readonly disabled (already the case for CLI by default on most systems).

    php -d phar.readonly=off dev/build-phar.php

    The executable is created at bin/opensim-rest-cli.

    Command-line client

    Download the executable from this repository, make sure opensim-rest-cli is executable and move it to /usr/local/bin/.

    chmod +x /path/to/opensim-rest-cli
sudo mv /path/to/opensim-rest-cli /usr/local/bin/opensim-rest-cli

    You can run commands like

    opensim-rest-cli /path/to/Robust.ini show info
opensim-rest-cli /path/to/Robust.ini show regions

    If you save the credentials in ~/.opensim-rest-cli.ini, you can skip the Robust.ini argument.

    opensim-rest-cli show info
opensim-rest-cli show regions

    PHP class

    Method 1: Install with composer (recommended for standalone projects)

    composer require magicoli/opensim-rest-php

    Then in your PHP code:

    
require_once 'vendor/autoload.php';

    $session = opensim_rest_session( array( ‘uri’ => "yourgrid.org:8009", ‘ConsoleUser’ => ‘yourConsoleUsername’, ‘ConsolePass’ => ‘yourConsolePassword’, ) );

    if ( is_opensim_rest_error($session) ) { error_log( "OpenSim_Rest error: " . $session->getMessage() ); } else { $responseLines = $session->sendCommand($command); }

    Return value: an array containing the line(s) of response or a PHP Error

    Method 2: Git Submodule + sparse (recommended for integrated projects)

    Setting sparse config is critical to avoid executables being accessible on public website.

    From your project directory:

    
git submodule add https://github.com/magicoli/opensim-rest-php.git opensim-rest
cd opensim-rest
git config core.sparseCheckout true

    echo ‘‘ > $(git rev-parse –git-dir)/info/sparse-checkout echo ‘!bin/‘ >> $(git rev-parse –git-dir)/info/sparse-checkout echo ‘!dev/*’ >> $(git rev-parse –git-dir)/info/sparse-checkout echo ‘!opensim-rest-cli.php’ >> $(git rev-parse –git-dir)/info/sparse-checkout echo ‘!composer.lock’ >> $(git rev-parse –git-dir)/info/sparse-checkout

    git read-tree -m -u HEAD

    This will give you only the files you need:

    opensim-rest/
├── class-rest.php
├── composer.json
├── LICENSE
└── README.md

    Then in your PHP code:

    require_once dirname(__FILE__) . '/opensim-rest/class-rest.php';
// Same usage as above

    Method 3: Manual download (not recommended)

    You won’t get updates…

    Download class-rest.php file in your project or

  • magiiic-autofeatureimage

    This is the long description. No limit, and you can use Markdown (as well as in the following sections).

    For backwards compatibility, if this section is missing, the full length of the short description will be used, and Markdown parsed.

    A few notes about the sections above:

    • "Contributors" is a comma separated list of wp.org/wp-plugins.org usernames
    • "Tags" is a comma separated list of tags that apply to the plugin
    • "Requires at least" is the lowest version that the plugin will work on
    • "Tested up to" is the highest version that you’ve successfully used to test the plugin. Note that it might work on higher versions… this is just the highest one you’ve verified.
    • Stable tag should indicate the Subversion "tag" of the latest stable version, or "trunk," if you use /trunk/ for stable.

    Note that the readme.txt of the stable tag is the one that is considered the defining one for the plugin, so if the /trunk/readme.txt file says that the stable tag is 4.3, then it is /tags/4.3/readme.txt that’ll be used for displaying information about the plugin. In this situation, the only thing considered from the trunk readme.txt is the stable tag pointer. Thus, if you develop in trunk, you can update the trunk readme.txt to reflect changes in your in-development version, without having that information incorrectly disclosed about the current stable version that lacks those changes — as long as the trunk’s readme.txt points to the correct stable tag.

    If no stable tag is provided, it is assumed that trunk is stable, but you should specify "trunk" if that’s where you put the stable version, in order to eliminate any doubt.

  • PHP Library for Project Version Management

    Version Stable License

    This library provides tasks for automating versioning of your PHP projects.

    It allows you to increment the version based on different levels (major, minor, patch, dev, beta, rc), and update version references in various files such as PHP files, README.md, package.json, and readme.txt.

    Installation

    Run the following command in your project directory:

    composer require --dev magicoli/php-bump-library

    And add the following script to your composer.json file:

     "scripts": {
    "bump-version": "robo --load-from=vendor/magicoli/php-bump-library/RoboFile.php bump:version"
  }

    Usage

    composer bump-version [level]

    Replace [level] with the desired level of version increment, such as major, minor, patch, rc, beta, or dev. If you ommit it, the default level is patch.

    Alternatively, you can run the script directly with the following command:

    robo bump:version
# or
robo --load-from=path/to/RoboFile.php bump:version

    Make sure to adjust RoboFile.php to the actual path of the file in your project.

    About Versioning

    Semantic Versioning follows a specific order of version increments:

    Development stages (M.m.p-stage):

    • Dev: development versions that are not yet stable or released.
    • Beta: pre-release versions that are closer to the stable release but may still have minor issues.
    • RC: release candidates, which are close to the final release but may require additional testing.

    Releases (M.m.p):

    • Patch: backward-compatible bug fixes.
    • Minor: added functionality, still backward-compatible manner.
    • Major: big bada boom.

    Note that dev, beta, and rc versions are considered inferior to the normal versions and are typically used in pre-release stages or development cycles: 1.0-dev < 1.0-beta < 1.0-rc < 1.0.

    For example, if your version is 1.0.0 and you bump it on the dev level, new version will be 1.0.1-dev (note the pach increment). If you bump the dev to beta, it will keep its main version and become 1.0.1-beta. And if you bump 1.0.1-beta without arguments, the new version will be 1.0.1.

    License

    This library is licensed under the AGPL-v3 License.

  • Oli’s Breadcrumbs

    Several ways to add breadcrumbs to your pages, if your theme does not support them. If you theme already supports breadcrumbs, you probably don’t need this plugin, as it is likely to have less options.

    You can add breadcrumbs with any of these methods:

    • [breadcrumbs] shortcode
    • Breadcrumbs widget
    • Breadcrumbs Divi Module (for Divi Themes or with Divi plugin)
    • Breadcrumbs Element WPBakery Page Builder (aka js_composer aka Visual Composer)

    Here are the options for the shordcode.

    • [breadcrumbs exclude-home="true"] do not start the breadcrumbs with home page, default false
    • [breadcrumbs exclude-archives="true"] do not include main articles archive link, default false
    • [breadcrumbs exclude-title="true"] do not end the breadcrumbs with the post title, default false
    • [breadcrumbs separator="×"] separator, default "/"

    Equivalent options are available in the widget and the Divi Module.

  • HotelDruid migration tool to WooCommerce (dev)

    This plugin is unstable. It addresses a specific need and is not intended for general distribution. Do not use it unless you are a developer and know what you do. You need to read, verify and adjust the code according to your needs.

    The intend of this plugin is to migrate booking data from an HotelDruid setup to a WordPress WooCommerce bookings solution.

  • Documents from Git – Oli’s version

    This WordPress Plugin lets you easily publish, collaborate on and version control your [Markdown, Jupyter notebook] documents directly from your favorite remote Git platform, even if it’s self-hosted.

    The advantages are:

    • Write documents in your favorite editor and just push to your remote repository to update your blog instantly
    • Use the power of version control: publish different versions of the document in different posts, i.e. from another branch or commit than latest master
    • Easy to update by your readers via pull requests, minimizing the chance of stale tutorials

    The following document types are currently supported:

    • Markdown
    • Jupyter notebooks (only for public repositories)

    The following platforms are currently supported:

    • Github
    • Bitbucket
    • Gitlab

    Usage

    Note, this plugin uses Github’s wonderful /markdown API to render to HTML. This comes with 2 caveats:

    1. Unless authenticated, the rate limit is set at 60 requests per minute. Since v1.1.0 the plugin is capable of statically caching content. In case that’s not dynamic enough for you, your only option currently is to not use any cache in which case every document will be pulled from your provider every time someone opens it on your site. Then it’s strongly recommended to create a Github access token and register it with the plugin. Then the rate limit will be set to 5000 requests per hour. See Global attributes section for details on how to do that.
    2. The Markdown content cannot exceed 400 KB, so roughly 400 000 characters incl whitespace. If not a monographic dissertation, this should not be an applicable limit though.

    Configuration

    In the main menu Settings > Documents from Git you can set all important global settings.

    Note: previous config.json is deprecated now due to security concerns.

    Shortcodes

    The features of the plugin are provided through shortcodes. You can use them in your posts, pages or custom post types.

    Publish documents

    [git-<platform>-<action>] The document-specific shortcode

    • <platform> can be one of
      • github: if you use Github as your VCS platform
      • bitbucket: if you use Bitbucket as your VCS platform
      • gitlab: if you use Gitlab as your VCS platform
    • <action> can be one of
      • markdown: Render your Markdown files hosted on your VCS platform in Github’s rendering style
      • jupyter: Render your Jupyter notebook hosted on your VCS platform (only for public repositories)
      • checkout: Renders a small badge-like box with a link to the document and the date of the last commit
      • history: Renders a <h2> section with the last commit dates, messages and authors

    Manipulate rendering style

    [git-add-css] adds a <div id="git-add-css" class="<classes_attribute>" to wrap content. That way you can manipulate the style freely with additional CSS classes. Follow these steps:

    1. Add a CSS file to your theme’s root folder, which contains some classes, e.g. class1, class2, class3
    2. Enqueue the CSS file by adding wp_enqueue_style('my-style', get_template_directory_uri().'/my-style.css'); to the theme’s functions.php
    3. Add the enclosing git-add-css shortcode to your post with the custom CSS classes in the classes attribute, e.g.:
    [git-add-css classes="class1 class2 class3"]
    [git-gitlab-checkout url=...]
    [git-gitlab-markdown url=...]
    [git-gitlab-history url=...]
[/git-add-css]

    Attributes

    Each shortcode takes a few attributes, indicating if it’s required for public or private repositories:

    • url: The URL of the document in the repository
      • Type: string
      • Action: all except git-add-css
      • Public repo: :ballot_box_with_check:
      • Private repo: :ballot_box_with_check:
    • user: The user name (not email) of an authorized user
      • Type: string
      • Action: all except git-add-css
      • Public repo: :negative_squared_cross_mark:
      • Private repo: :ballot_box_with_check:
    • token: The access token/app password for the authorized user
      • Type: string
      • Action: all except git-add-css
      • Public repo: :negative_squared_cross_mark:
      • Private repo: :ballot_box_with_check:
    • cache_ttl: The time in seconds that the plugin will cache, only for cache_strategy=static.
      • Type: integer
      • Action: all except git-add-css
      • Public repo: :negative_squared_cross_mark:
      • Private repo: :negative_squared_cross_mark:
    • cache_strategy: Only static caching is implemented so far. dynamic caching is on the way!
      • Type: integer
      • Action: all except git-add-css
      • Public repo: :negative_squared_cross_mark:
      • Private repo: :negative_squared_cross_mark:
    • limit: Limits the history of commits to this number. Default 5.
      • Type: integer
      • Action: history
      • Public repo: :negative_squared_cross_mark:
      • Private repo: :negative_squared_cross_mark:
    • classes: The additional CSS classes to render the content with
      • Type: string
      • Action: git-add-css
      • Public repo: :ballot_box_with_check:
      • Private repo: :ballot_box_with_check:

    Caching

    Often we need to prioritize speed when loading content and, in addition, it is very costly to fetch, load and format the content every time we need to read the content of the post.

    This plugin soon offers 2 methods for caching, static and dynamic which can be set via the cache_strategy property.

    • Static caching (cache_strategy=static)

    This is the default strategy, as it doesn’t require any user action.

    The property cache_ttl sets how many seconds the content cache will keep alive.

    Currently there’s no way to flush the cache manually. However, changing cache_ttl or the history limit will create a new cache.

    • Dynamic caching (cache_strategy=dynamic)

    This is not implemented yet. See #20 for details.

    Token authorization

    You need to authorize via user and token if you intend to publish from a private repository. You don’t need to authorize if the repository is open.

    However, keep in mind that some platforms have stricter API limits for anonymous requests which are greatly extended if you provide your credentials. So even for public repos it could make sense. And unless you use this plugin’s caching capabilities, it’s strongly recommended to register a Github access token regardless of the VCS hosting platform, see the beginning of the chapter.

    How to generate the token depends on your platform:

    This plugin needs only Read access to your repositories. Keep that in mind when creating an access token.

    Examples

    We publish our own tutorials with this plugin: https://gis-ops.com/tutorials/.

    • Publish Markdown from Github

    [git-github-markdown url="https://github.com/gis-ops/tutorials/blob/master/qgis/QGIS_SimplePlugin.md"]

    • Publish Markdown from Github with 1 hour cache

    [git-github-markdown url="https://github.com/gis-ops/tutorials/blob/master/qgis/QGIS_SimplePlugin.md" cache_ttl="3600" cache_strategy="static"]

    • Publish Jupyter notebook from Github

    [git-github-jupyter url="https://github.com/GIScience/openrouteservice-examples/blob/master/python/ortools_pubcrawl.ipynb"]

    • Publish from a private repository

    [git-bitbucket-jupyter user=nilsnolde token=3292_2p3a_84-2af url="https://bitbucket.org/nilsnolde/test-wp-plugin/src/master/README.md"]

    • Display last commit and document URL from Bitbucket

    [git-bitbucket-checkout url="https://bitbucket.org/nilsnolde/test-wp-plugin/src/master/README.md"]

    • Display commit history from Gitlab

    git-gitlab-history limit=5 url="https://gitlab.com/nilsnolde/esy-osm-pbf/-/blob/master/README.md"]

    • Use additional CSS classes to style

    The following example will put a dashed box around the whole post:

        [git-add-css classes="md-dashedbox"]
        [git-github-checkout url="https://github.com/gis-ops/tutorials/blob/master/qgis/QGIS_SimplePlugin.md"]
        [git-github-markdown url="https://github.com/gis-ops/tutorials/blob/master/qgis/QGIS_SimplePlugin.md"]
        [git-github-history url="https://github.com/gis-ops/tutorials/blob/master/qgis/QGIS_SimplePlugin.md"]
    [/git-add-css]

    With the following CSS file contents enqueued to your theme:

    
    div.md_dashedbox {
        position: relative;
        font-size: 0.75em;
        border: 3px dashed;
        padding: 10px;
        margin-bottom:15px
    }

    div.md_dashedbox div.markdown-github { color:white; line-height: 20px; padding: 0px 5px; position: absolute; background-color: #345; top: -3px; left: -3px; text-transform:none; font-size:1em; font-family: "Helvetica Neue",Helvetica,Arial,sans-serif; }

    Installation

    WordPress.org

    The latest version is on Oli’s GitHub repository

    https://github.com/magicoli/documents-from-git

    There is no automatic update process from GitHub. You need to download the latest release and upload it to your WordPress installation, or, for advanced users, clone the repository into your wp-content/plugins folder and use git features.

    Note: The release from the original author on WordPress plugin store is deprecated and does not receive updates Documents from Git.

    Troubleshooting

    For troubleshooting and frequently asked questions, please refer to the FAQ page.

    Acknowledgements

    Contributions from other projects

    The file structure has been reorganised from the original version to make it more maintainable and to follow WordPress best practices, mainly bringing the wordpress file structure to the root folder, so applying this repo modifications to an original clone might need some extra preparation, but is not impossible.

    PDC Sponsored the Bitbucket integration.

  • bookings-calendar-sync

    Moved to https://github.com/magicoli/hoteldruid-migration