DocsLibs.json

[
    {
        "name": "lume",
        "author": "rxi",
        "url": "https://github.com/rxi/lume",
        "description": "A collection of functions for Lua, geared towards game development.",
        "api": [
            {
                "name": "clamp",
                "arguments": "x, min, max",
                "description": "Returns the number `x` clamped between the numbers `min` and `max`"
            },
            {
                "name": "round",
                "arguments": "x [, increment]",
                "description": "Rounds `x` to the nearest integer; rounds away from zero if we're midway between two integers. If `increment` is set then the number is rounded to the nearest increment.",
                "example": "lume.round(2.3) -- Returns 2\nlume.round(123.4567, .1) -- Returns 123.5"
            },
            {
                "name": "sign",
                "arguments": "x",
                "description": "Returns `1` if `x` is 0 or above, returns `-1` when `x` is negative."
            },
            {
                "name": "lerp",
                "arguments": "a, b, amount",
                "description": "Returns the linearly interpolated number between `a` and `b`, `amount` should be in the range of 0 - 1; if `amount` is outside of this range it is clamped.",
                "example": "lume.lerp(100, 200, .5) -- Returns 150"
            },
            {
                "name": "smooth",
                "arguments": "a, b, amount",
                "description": "Similar to `lume.lerp()` but uses cubic interpolation instead of linear interpolation."
            },
            {
                "name": "pingpong",
                "arguments": "x",
                "description": "Ping-pongs the number `x` between 0 and 1."
            },
            {
                "name": "distance",
                "arguments": "x1, y1, x2, y2 [, squared]",
                "description": "Returns the distance between the two points. If `squared` is true then the squared distance is returned -- this is faster to calculate and can still be used when comparing distances."
            },
            {
                "name": "angle",
                "arguments": "x1, y1, x2, y2",
                "description": "Returns the angle between the two points."
            },
            {
                "name": "vector",
                "arguments": "angle, magnitude",
                "description": "Given an `angle` and `magnitude`, returns a vector.",
                "example": "local x, y = lume.vector(0, 10) -- Returns 10, 0"
            },
            {
                "name": "random",
                "arguments": "[a [, b]]",
                "description": "Returns a random number between `a` and `b`. If only `a` is supplied a number between `0` and `a` is returned. If no arguments are supplied a random number between `0` and `1` is returned."
            },
            {
                "name": "randomchoice",
                "arguments": "t",
                "description": "Returns a random value from array `t`. If the array is empty an error is raised.",
                "example": "lume.randomchoice({true, false}) -- Returns either true or false"
            },
            {
                "name": "weightedchoice",
                "arguments": "t",
                "description": "Takes the argument table `t` where the keys are the possible choices and the value is the choice's weight. A weight should be 0 or above, the larger the number the higher the probability of that choice being picked. If the table is empty, a weight is below zero or all the weights are 0 then an error is raised.",
                "example": "lume.weightedchoice({ [\"cat\"] = 10, [\"dog\"] = 5, [\"frog\"] = 0 })\n-- Returns either \"cat\" or \"dog\" with \"cat\" being twice as likely to be chosen."
            },
            {
                "name": "isarray",
                "arguments": "x",
                "description": "Returns `true` if `x` is an array -- the value is assumed to be an array if it is a table which contains a value at the index `1`. This function is used internally and can be overridden if you wish to use a different method to detect arrays."
            },
            {
                "name": "push",
                "arguments": "t, ...",
                "description": "Pushes all the given values to the end of the table `t` and returns the pushed values. Nil values are ignored.",
                "example": "local t = { 1, 2, 3 }\nlume.push(t, 4, 5) -- `t` becomes { 1, 2, 3, 4, 5 }"
            },
            {
                "name": "remove",
                "arguments": "t, x",
                "description": "Removes the first instance of the value `x` if it exists in the table `t`. Returns `x`.",
                "example": "local t = { 1, 2, 3 }\nlume.remove(t, 2) -- `t` becomes { 1, 3 }"
            },
            {
                "name": "clear",
                "arguments": "t",
                "description": "Nils all the values in the table `t`, this renders the table empty. Returns `t`.",
                "example": "local t = { 1, 2, 3 }\nlume.clear(t) -- `t` becomes {}"
            },
            {
                "name": "extend",
                "arguments": "t, ...",
                "description": "Copies all the fields from the source tables to the table `t` and returns `t`. If a key exists in multiple tables the right-most table's value is used.",
                "example": "local t = { a = 1, b = 2 }\nlume.extend(t, { b = 4, c = 6 }) -- `t` becomes { a = 1, b = 4, c = 6 }"
            },
            {
                "name": "shuffle",
                "arguments": "t",
                "description": "Returns a shuffled copy of the array `t`."
            },
            {
                "name": "sort",
                "arguments": "t [, comp]",
                "description": "Returns a copy of the array `t` with all its items sorted. If `comp` is a function it will be used to compare the items when sorting. If `comp` is a string it will be used as the key to sort the items by.",
                "example": "lume.sort({ 1, 4, 3, 2, 5 }) -- Returns { 1, 2, 3, 4, 5 }\nlume.sort({ {z=2}, {z=3}, {z=1} }, \"z\") -- Returns { {z=1}, {z=2}, {z=3} }\nlume.sort({ 1, 3, 2 }, function(a, b) return a > b end) -- Returns { 3, 2, 1 }"
            },
            {
                "name": "array",
                "arguments": "...",
                "description": "Iterates the supplied iterator and returns an array filled with the values.",
                "example": "lume.array(string.gmatch(\"Hello world\", \"%a+\")) -- Returns {\"Hello\", \"world\"}"
            },
            {
                "name": "each",
                "arguments": "t, fn, ...",
                "description": "Iterates the table `t` and calls the function `fn` on each value followed by the supplied additional arguments; if `fn` is a string the method of that name is called for each value. The function returns `t` unmodified.",
                "example": "lume.each({1, 2, 3}, print) -- Prints \"1\", \"2\", \"3\" on separate lines\nlume.each({a, b, c}, \"move\", 10, 20) -- Does x:move(10, 20) on each value"
            },
            {
                "name": "map",
                "arguments": "t, fn",
                "description": "Applies the function `fn` to each value in table `t` and returns a new table with the resulting values.",
                "example": "lume.map({1, 2, 3}, function(x) return x * 2 end) -- Returns {2, 4, 6}"
            },
            {
                "name": "all",
                "arguments": "t [, fn]",
                "description": "Returns true if all the values in `t` table are true. If a `fn` function is supplied it is called on each value, true is returned if all of the calls to `fn` return true.",
                "example": "lume.all({1, 2, 1}, function(x) return x == 1 end) -- Returns false"
            },
            {
                "name": "any",
                "arguments": "t [, fn]",
                "description": "Returns true if any of the values in `t` table are true. If a `fn` function is supplied it is called on each value, true is returned if any of the calls to `fn` return true.",
                "example": "lume.any({1, 2, 1}, function(x) return x == 1 end) -- Returns true"
            },
            {
                "name": "reduce",
                "arguments": "t, fn [, first]",
                "description": "Applies `fn` on two arguments cumulative to the items of the array `t`, from left to right, so as to reduce the array to a single value. If a `first` value is specified the accumulator is initialised to this, otherwise the first value in the array is used. If the array is empty and no `first` value is specified an error is raised.",
                "example": "lume.reduce({1, 2, 3}, function(a, b) return a + b end) -- Returns 6"
            },
            {
                "name": "unique",
                "arguments": "t",
                "description": "Returns a copy of the `t` array with all the duplicate values removed.",
                "example": "lume.unique({2, 1, 2, \"cat\", \"cat\"}) -- Returns {1, 2, \"cat\"}"
            },
            {
                "name": "filter",
                "arguments": "t, fn [, retainkeys]",
                "description": "Calls `fn` on each value of `t` table. Returns a new table with only the values where `fn` returned true. If `retainkeys` is true the table is not treated as an array and retains its original keys.",
                "example": "lume.filter({1, 2, 3, 4}, function(x) return x % 2 == 0 end) -- Returns {2, 4}"
            },
            {
                "name": "reject",
                "arguments": "t, fn [, retainkeys]",
                "description": "The opposite of `lume.filter()`: Calls `fn` on each value of `t` table; returns a new table with only the values where `fn` returned false. If `retainkeys` is true the table is not treated as an array and retains its original keys.",
                "example": "lume.reject({1, 2, 3, 4}, function(x) return x % 2 == 0 end) -- Returns {1, 3}"
            },
            {
                "name": "merge",
                "arguments": "...",
                "description": "Returns a new table with all the given tables merged together. If a key exists in multiple tables the right-most table's value is used.",
                "example": "lume.merge({a=1, b=2, c=3}, {c=8, d=9}) -- Returns {a=1, b=2, c=8, d=9}"
            },
            {
                "name": "concat",
                "arguments": "...",
                "description": "Returns a new array consisting of all the given arrays concatenated into one.",
                "example": "lume.concat({1, 2}, {3, 4}, {5, 6}) -- Returns {1, 2, 3, 4, 5, 6}"
            },
            {
                "name": "find",
                "arguments": "t, value",
                "description": "Returns the index/key of `value` in `t`. Returns `nil` if that value does not exist in the table.",
                "example": "lume.find({\"a\", \"b\", \"c\"}, \"b\") -- Returns 2"
            },
            {
                "name": "match",
                "arguments": "t, fn",
                "description": "Returns the value and key of the value in table `t` which returns true when `fn` is called on it. Returns `nil` if no such value exists.",
                "example": "lume.match({1, 5, 8, 7}, function(x) return x % 2 == 0 end) -- Returns 8, 3"
            },
            {
                "name": "count",
                "arguments": "t [, fn]",
                "description": "Counts the number of values in the table `t`. If a `fn` function is supplied it is called on each value, the number of times it returns true is counted.",
                "example": "lume.count({a = 2, b = 3, c = 4, d = 5}) -- Returns 4\nlume.count({1, 2, 4, 6}, function(x) return x % 2 == 0 end) -- Returns 3"
            },
            {
                "name": "slice",
                "arguments": "t [, i [, j]]",
                "description": "Mimics the behaviour of Lua's `string.sub`, but operates on an array rather than a string. Creates and returns a new array of the given slice.",
                "example": "lume.slice({\"a\", \"b\", \"c\", \"d\", \"e\"}, 2, 4) -- Returns {\"b\", \"c\", \"d\"}"
            },
            {
                "name": "first",
                "arguments": "t [, n]",
                "description": "Returns the first element of an array or nil if the array is empty. If `n` is specificed an array of the first `n` elements is returned.",
                "example": "lume.first({\"a\", \"b\", \"c\"}) -- Returns \"a\""
            },
            {
                "name": "last",
                "arguments": "t [, n]",
                "description": "Returns the last element of an array or nil if the array is empty. If `n` is specificed an array of the last `n` elements is returned.",
                "example": "lume.last({\"a\", \"b\", \"c\"}) -- Returns \"c\""
            },
            {
                "name": "invert",
                "arguments": "t",
                "description": "Returns a copy of the table where the keys have become the values and the values the keys.",
                "example": "lume.invert({a = \"x\", b = \"y\"}) -- returns {x = \"a\", y = \"b\"}"
            },
            {
                "name": "pick",
                "arguments": "t, ...",
                "description": "Returns a copy of the table filtered to only contain values for the given keys.",
                "example": "lume.pick({ a = 1, b = 2, c = 3 }, \"a\", \"c\") -- Returns { a = 1, c = 3 }"
            },
            {
                "name": "keys",
                "arguments": "t",
                "description": "Returns an array containing each key of the table."
            },
            {
                "name": "clone",
                "arguments": "t",
                "description": "Returns a shallow copy of the table `t`."
            },
            {
                "name": "fn",
                "arguments": "fn, ...",
                "description": "Creates a wrapper function around function `fn`, automatically inserting the arguments into `fn` which will persist every time the wrapper is called. Any arguments which are passed to the returned function will be inserted after the already existing arguments passed to `fn`.",
                "example": "local f = lume.fn(print, \"Hello\")\nf(\"world\") -- Prints \"Hello world\""
            },
            {
                "name": "once",
                "arguments": "fn, ...",
                "description": "Returns a wrapper function to `fn` which takes the supplied arguments. The wrapper function will call `fn` on the first call and do nothing on any subsequent calls.",
                "example": "local f = lume.once(print, \"Hello\")\nf() -- Prints \"Hello\"f() -- Does nothing"
            },
            {
                "name": "memoize",
                "arguments": "fn",
                "description": "Returns a wrapper function to `fn` where the results for any given set of arguments are cached. `lume.memoize()` is useful when used on functions with slow-running computations.",
                "example": "fib = lume.memoize(function(n) return n < 2 and n or fib(n-1) + fib(n-2) end)"
            },
            {
                "name": "combine",
                "arguments": "...",
                "description": "Creates a wrapper function which calls each supplied argument in the order they were passed to `lume.combine()`; nil arguments are ignored. The wrapper function passes its own arguments to each of its wrapped functions when it is called.",
                "example": "local f = lume.combine(function(a, b) print(a + b) end,\n                       function(a, b) print(a * b) end)\nf(3, 4) -- Prints \"7\" then \"12\" on a new line"
            },
            {
                "name": "call",
                "arguments": "fn, ...",
                "description": "Calls the given function with the provided arguments and returns its values. If `fn` is `nil` then no action is performed and the function returns `nil`.",
                "example": "lume.call(print, \"Hello world\") -- Prints \"Hello world\""
            },
            {
                "name": "time",
                "arguments": "fn, ...",
                "description": "Inserts the arguments into function `fn` and calls it. Returns the time in seconds the function `fn` took to execute followed by `fn`'s returned values.",
                "example": "lume.time(function(x) return x end, \"hello\") -- Returns 0, \"hello\""
            },
            {
                "name": "lambda",
                "arguments": "str",
                "description": "Takes a string lambda and returns a function. `str` should be a list of comma-separated parameters, followed by `->`, followed by the expression which will be evaluated and returned.",
                "example": "local f = lume.lambda \"x,y -> 2*x+y\"\nf(10, 5) -- Returns 25"
            },
            {
                "name": "serialize",
                "arguments": "x",
                "description": "Serializes the argument `x` into a string which can be loaded again using `lume.deserialize()`. Only booleans, numbers, tables and strings can be serialized. Circular references will result in an error; all nested tables are serialized as unique tables.",
                "example": "lume.serialize({a = \"test\", b = {1, 2, 3}, false})\n-- Returns \"{[1]=false,[\"a\"]=\"test\",[\"b\"]={[1]=1,[2]=2,[3]=3,},}\""
            },
            {
                "name": "deserialize",
                "arguments": "str",
                "description": "Deserializes a string created by `lume.serialize()` and returns the resulting value. This function should not be run on an untrusted string.",
                "example": "lume.deserialize(\"{1, 2, 3}\") -- Returns {1, 2, 3}"
            },
            {
                "name": "split",
                "arguments": "str [, sep]",
                "description": "Returns an array of the words in the string `str`. If `sep` is provided it is used as the delimiter, consecutive delimiters are not grouped together and will delimit empty strings.",
                "example": "lume.split(\"One two three\") -- Returns {\"One\", \"two\", \"three\"}"
            },
            {
                "name": "trim",
                "arguments": "str [, chars]",
                "description": "Trims the whitespace from the start and end of the string `str` and returns the new string. If a `chars` value is set the characters in `chars` are trimmed instead of whitespace.",
                "example": "lume.trim(\"  Hello  \") -- Returns \"Hello\""
            },
            {
                "name": "wordwrap",
                "arguments": "str [, limit]",
                "description": "Returns `str` wrapped to `limit` number of characters per line, by default `limit` is `72`. `limit` can also be a function which when passed a string, returns `true` if it is too long for a single line.",
                "example": "-- Returns \"Hello world\nThis is a\nshort string\"\nlume.wordwrap(\"Hello world. This is a short string\", 14)"
            },
            {
                "name": "format",
                "arguments": "str [, vars]",
                "description": "Returns a formatted string. The values of keys in the table `vars` can be inserted into the string by using the form `\"{key}\"` in `str`; numerical keys can also be used.",
                "example": "lume.format(\"{b} hi {a}\", {a = \"mark\", b = \"Oh\"}) -- Returns \"Oh hi mark\"\nlume.format(\"Hello {1}!\", {\"world\"}) -- Returns \"Hello world!\""
            },
            {
                "name": "trace",
                "arguments": "...",
                "description": "Prints the current filename and line number followed by each argument separated by a space.",
                "example": "-- Assuming the file is called \"example.lua\" and the next line is 12:\nlume.trace(\"hello\", 1234) -- Prints \"example.lua:12: hello 1234\""
            },
            {
                "name": "dostring",
                "arguments": "str",
                "description": "Executes the lua code inside `str`.",
                "example": "lume.dostring(\"print('Hello!')\") -- Prints \"Hello!\""
            },
            {
                "name": "uuid",
                "arguments": "",
                "description": "Generates a random UUID string; version 4 as specified in [RFC 4122](http://www.ietf.org/rfc/rfc4122.txt)."
            },
            {
                "name": "hotswap",
                "arguments": "modname",
                "description": "Reloads an already loaded module in place, allowing you to immediately see the effects of code changes without having to restart the program. `modname` should be the same string used when loading the module with require(). In the case of an error the global environment is restored and `nil` plus an error message is returned.",
                "example": "lume.hotswap(\"lume\") -- Reloads the lume module\nassert(lume.hotswap(\"inexistant_module\")) -- Raises an error"
            },
            {
                "name": "ripairs",
                "arguments": "t",
                "description": "Performs the same function as `ipairs()` but iterates in reverse; this allows the removal of items from the table during iteration without any items being skipped.",
                "example": "-- Prints \"3->c\", \"2->b\" and \"1->a\" on separate lines\nfor i, v in lume.ripairs({ \"a\", \"b\", \"c\" }) do\n  print(i .. \"->\" .. v)\nend"
            },
            {
                "name": "color",
                "arguments": "str [, mul]",
                "description": "Takes color string `str` and returns 4 values, one for each color channel (`r`, `g`, `b` and `a`). By default the returned values are between 0 and 1; the values are multiplied by the number `mul` if it is provided.",
                "example": "lume.color(\"#ff0000\")               -- Returns 1, 0, 0, 1\nlume.color(\"rgba(255, 0, 255, .5)\") -- Returns 1, 0, 1, .5\nlume.color(\"#00ffff\", 256)          -- Returns 0, 256, 256, 256\nlume.color(\"rgb(255, 0, 0)\", 256)   -- Returns 256, 0, 0, 256"
            },
            {
                "name": "chain",
                "arguments": "value",
                "description": "Returns a wrapped object which allows chaining of lume functions. The function result() should be called at the end of the chain to return the resulting value.",
                "example": "lume.chain({1, 2, 3, 4})\n  :filter(function(x) return x % 2 == 0 end)\n  :map(function(x) return -x end)\n  :result() -- Returns { -2, -4 }"
            }
        ]
    },
    {
        "name": "batteries",
        "author": "1bardesign",
        "url": "https://github.com/1bardesign/batteries",
        "description": "batteries fills out lua's sparse standard library a little, and provides implementations of common algorithms and data structures useful for games.",
        "api": [
            {
                "name": "assert:some",
                "arguments": "v, msg, stack_level",
                "description": "assert a value is not nil, returns the value"
            },
            {
                "name": "assert:equal",
                "arguments": "a, b, msg, stack_level",
                "description": "assert two values are equal"
            },
            {
                "name": "assert:not_equal",
                "arguments": "a, b, msg, stack_level",
                "description": "assert two values are not equal"
            },
            {
                "name": "assert:type",
                "arguments": "a, t, msg, stack_level",
                "description": "assert a value is of a certain type"
            },
            {
                "name": "assert:nop",
                "arguments": "",
                "description": "Replace everything in assert with nop functions that just return their second argument, for near-zero overhead on release"
            },
            {
                "name": "mathx.wrap",
                "arguments": "v, lo, hi",
                "description": "Wrap v around range [lo, hi]"
            },
            {
                "name": "mathx.wrap_index",
                "arguments": "i, t",
                "description": "Wrap i around the indices of t"
            },
            {
                "name": "mathx.clamp",
                "arguments": "v, lo, hi",
                "description": "Clamp v to range [lo, hi]"
            },
            {
                "name": "mathx.clamp01",
                "arguments": "v",
                "description": "Clamp v to range [0, 1]"
            },
            {
                "name": "mathx.round",
                "arguments": "v",
                "description": "Round v to nearest whole, away from zero"
            },
            {
                "name": "mathx.to_one_in",
                "arguments": "v, x",
                "description": "Round v to one-in x"
            },
            {
                "name": "mathx.to_precision",
                "arguments": "v, decimal_points",
                "description": "Round v to a given decimal precision"
            },
            {
                "name": "mathx.sign",
                "arguments": "v",
                "description": "0, 1, -1 sign of a scalar"
            },
            {
                "name": "mathx.lerp",
                "arguments": "a, b, t",
                "description": "Linear interpolation between a and b"
            },
            {
                "name": "mathx.lerp_eps",
                "arguments": "a, b, t, eps",
                "description": "Linear interpolation with a minimum \"final step\" distance\nUseful for making sure dynamic lerps do actually reach their final destination"
            },
            {
                "name": "mathx.bilerp",
                "arguments": "a, b, c, d, u, v",
                "description": "Bilinear interpolation between 4 samples"
            },
            {
                "name": "mathx.smoothstep",
                "arguments": "v",
                "description": "Classic smoothstep\n(Only \"safe\" for 0-1 range)"
            },
            {
                "name": "mathx.smootherstep",
                "arguments": "v",
                "description": "Classic smootherstep; zero 2nd order derivatives at 0 and 1\n(Only safe for 0-1 range)"
            },
            {
                "name": "mathx.random_sign",
                "arguments": "_r",
                "description": "Return a random sign"
            },
            {
                "name": "mathx.random_lerp",
                "arguments": "min, max, _r",
                "description": "Return a random value between two numbers (continuous)"
            },
            {
                "name": "mathx.isnan",
                "arguments": "v",
                "description": "Nan checking"
            },
            {
                "name": "mathx.tau",
                "callable": false,
                "description": "Superior constant handy for expressing things in turns"
            },
            {
                "name": "mathx.normalise_angle",
                "arguments": "a",
                "description": "Normalise angle onto the interval [-math.pi, math.pi)\nSo each angle only has a single value representing it"
            },
            {
                "name": "mathx.normalize_angle",
                "arguments": "a",
                "description": "Normalize angle onto the interval [-math.pi, math.pi)\nSo each angle only has a single value representing it"
            },
            {
                "name": "mathx.angle_difference",
                "arguments": "a, b",
                "description": "Get the normalised difference between two angles"
            },
            {
                "name": "mathx.lerp_angle",
                "arguments": "a, b, t",
                "description": "Mathx.lerp equivalent for angles"
            },
            {
                "name": "mathx.lerp_angle_eps",
                "arguments": "a, b, t, eps",
                "description": "Mathx.lerp_eps equivalent for angles"
            },
            {
                "name": "mathx.rotate",
                "arguments": "x, y, r",
                "description": "Rotate a point around the origin by an angle"
            },
            {
                "name": "mathx.length",
                "arguments": "x, y",
                "description": "Get the length of a vector from the origin"
            },
            {
                "name": "mathx.distance",
                "arguments": "x1, y1, x2, y2",
                "description": "Get the distance between two points"
            },
            {
                "name": "stringx.split",
                "arguments": "self, delim",
                "description": "Split a string on a delimiter into an ordered table"
            },
            {
                "name": "stringx.trim",
                "arguments": "s",
                "description": "Trim all whitespace off the head and tail of a string\nSpecifically trims space, tab, newline, and carriage return characters\nIgnores form feeds, vertical tabs, and backspaces"
            },
            {
                "name": "stringx.ltrim",
                "arguments": "s",
                "description": "Trim the start of a string"
            },
            {
                "name": "stringx.rtrim",
                "arguments": "s",
                "description": "Trim the end of a string"
            },
            {
                "name": "stringx.deindent",
                "arguments": "s, keep_trailing_empty",
                "description": "Remove identation from a string"
            },
            {
                "name": "stringx.apply_template",
                "arguments": "s, sub",
                "description": "Apply a template to a string\nie ('hello $name'):format({name = 'tom'}) == 'hello tom'"
            },
            {
                "name": "stringx.contains",
                "arguments": "haystack, needle",
                "description": "Check if a given string contains another (without garbage)"
            },
            {
                "name": "stringx.starts_with",
                "arguments": "s, prefix",
                "description": "Check if a given string starts with another (without garbage)"
            },
            {
                "name": "stringx.ends_with",
                "arguments": "s, suffix",
                "description": "Check if a given string ends with another (without garbage)"
            },
            {
                "name": "functional.identity",
                "arguments": "v",
                "description": "The identity function, returns the value"
            },
            {
                "name": "functional.foreach",
                "arguments": "t, f",
                "description": "Simple sequential iteration, f is called for all elements of t\nf can return non-nil to break the loop (and return the value)"
            },
            {
                "name": "functional.reduce",
                "arguments": "t, seed, f",
                "description": "Iteratively performs a left to right reduction of t using f, with seed as the initial value"
            },
            {
                "name": "functional.map",
                "arguments": "t, f",
                "description": "Maps a sequence {a, b, c} -> {f(a), f(b), f(c)}, automatically drops any nils"
            },
            {
                "name": "functional.map_inplace",
                "arguments": "t, f",
                "description": "Maps a sequence inplace, modifying it {a, b, c} -> {f(a), f(b), f(c)}"
            },
            {
                "name": "functional.filter",
                "arguments": "t, f",
                "description": "Filters a sequence by returning a table containing items where f(v, i) returns truthy"
            },
            {
                "name": "functional.filter_inplace",
                "arguments": "t, f",
                "description": "Filters a sequence in place, modifying it"
            },
            {
                "name": "functional.remove_if",
                "arguments": "t, f",
                "description": "Complement of filter, returns a table containing items where f(v) returns falsey"
            },
            {
                "name": "functional.partition",
                "arguments": "t, f",
                "description": "Partitions a sequence into two, based on filter criteria, simultaneous filter and remove_if"
            },
            {
                "name": "functional.group_by",
                "arguments": "t, f",
                "description": "Returns a table where the elements in t are grouped into sequential tables by the result of f on each element"
            },
            {
                "name": "functional.zip",
                "arguments": "t1, t2, f",
                "description": "Zips two sequences together into a new table, based on another function"
            },
            {
                "name": "functional.stitch",
                "arguments": "t, f",
                "description": "Maps a sequence {a, b, c} -> collapse { f(a), f(b), f(c) }"
            },
            {
                "name": "functional.cycle",
                "arguments": "t, f",
                "description": "Maps a sequence {a, b, c} -> { f(a, b), f(b, c), f(c, a) }"
            },
            {
                "name": "functional.generate",
                "arguments": "count, f",
                "description": "Generate data into a table, basically a map on numeric values from 1 to count"
            },
            {
                "name": "functional.generate_2d",
                "arguments": "t, f",
                "description": "2d version of generate() but ends up with a 1d table"
            },
            {
                "name": "functional.any",
                "arguments": "t, f",
                "description": "True if any element of the table matches f"
            },
            {
                "name": "functional.none",
                "arguments": "t, f",
                "description": "True if no element of the table matches f"
            },
            {
                "name": "functional.all",
                "arguments": "t, f",
                "description": "True if all elements of the table match f"
            },
            {
                "name": "functional.count",
                "arguments": "t, f",
                "description": "Counts the elements of t that match f"
            },
            {
                "name": "functional.contains",
                "arguments": "t, e",
                "description": "True if the table contains element e"
            },
            {
                "name": "functional.sum",
                "arguments": "t",
                "description": "Return the numeric sum of all elements of t"
            },
            {
                "name": "functional.mean",
                "arguments": "t",
                "description": "Return the numeric mean of all elements of t"
            },
            {
                "name": "functional.minmax",
                "arguments": "t",
                "description": "Return the minimum and maximum of t in one pass or zero for both if t is empty"
            },
            {
                "name": "functional.max",
                "arguments": "t",
                "description": "Return the maximum element of t or zero if t is empty"
            },
            {
                "name": "functional.min",
                "arguments": "t",
                "description": "Return the minimum element of t or zero if t is empty"
            },
            {
                "name": "functional.find_min",
                "arguments": "t, f",
                "description": "Return the element of the table that results in the lowest numeric value"
            },
            {
                "name": "functional.find_max",
                "arguments": "t, f",
                "description": "Return the element of the table that results in the greatest numeric value"
            },
            {
                "name": "functional.find_nearest",
                "arguments": "t, f, target",
                "description": "Return the element of the table that results in the value nearest to the passed value"
            },
            {
                "name": "functional.find_match",
                "arguments": "t, f",
                "description": "Return the first element of the table that results in a true filter"
            }
        ]
    },
    {
        "name": "step",
        "author": "Sheepolution",
        "url": "https://github.com/sheepolution/step",
        "description": "A small immediate mode timer module that makes it easier to have an action execute with a certain interval or after a delay.",
        "callType": ".",
        "api": [
            {
                "name": "every",
                "arguments": "duration [, max_duration]",
                "description": "Creates a timer which returns true every `duration` seconds. If `max_duration` is set the duration will be a random float between `duration` and `max_duration` every loop.",
                "example": "timer = step.every(3)\nif timer:update(dt) then\n  print(\"This will be printed every 3 seconds\")\nend"
            },
            {
                "name": "update",
                "arguments": "dt",
                "description": "Update the timer with `timer:update(dt)` or by calling your timer (`timer(dt)`) and pass the delta time as argument.",
                "example": "if timer(dt) then\n  print(\"This will be printed every 3 seconds.\")\nend"
            },
            {
                "name": "after",
                "arguments": "duration [, max_duration]",
                "description": "Creates a timer which continuously returns true after `duration` seconds. If `max_duration` is set the duration will be a random float between `duration` and `max_duration` every reset.",
                "example": "timer = step.after(3)\nif timer:update(dt) then\n  print(\"After 3 seconds this will be printed every frame.\")\nend"
            },
            {
                "name": "once",
                "arguments": "duration [, max_duration]",
                "description": "Creates a timer which returns true once after `duration` seconds. If `max_duration` is set the duration will be a random float between `duration` and `max_duration` every reset.",
                "example": "timer = step.once(3)\nif timer:update(dt) then\n  print(\"After 3 seconds this will be printed once.\")\nend"
            },
            {
                "name": "during",
                "arguments": "duration [, max_duration]",
                "description": "Creates a timer which returns true until after `duration` seconds. If `max_duration` is set the duration will be a random float between `duration` and `max_duration` every reset.",
                "example": "timer = step.once(3)\nif timer:update(dt) then\n  print(\"This will be printed every frame until 3 seconds have passed.\")\nend"
            },
            {
                "name": "reset",
                "description": "You can always reset your timer with `timer:reset()` or simply calling your timer without arguments.",
                "example": "timer:reset()\ntimer()"
            },
            {
                "name": "set",
                "arguments": "t [, noreset]",
                "description": "Change the time for this timer. Will also reset the timer unless `noreset` is `true`.",
                "example": "timer = step.every(5)\ntimer:set(3) --Now it will loop every 3 seconds instead."
            },
            {
                "name": "finish",
                "description": "Set the timer to the end so that on the next update it will return `true` for a `once` and `every` timer.",
                "example": "timer = step.new(4.7)\ntimer:finish()\nif timer(dt) then\n  print(\"On the first frame this will be printed and then again after 4.7 seconds.\")\nend"
            }
        ]
    },
    {
        "name": "3DreamEngine",
        "author": "3dreamengine",
        "url": "https://github.com/3dreamengine/3DreamEngine",
        "description": "An awesome 3D engine for LÖVE."
    },
    {
        "name": "anim9",
        "author": "excessive",
        "url": "https://github.com/excessive/anim9",
        "description": "3D skeletal animation library (design to be used with IQM and IQE)"
    },
    {
        "name": "Brinevector3D",
        "author": "flamendless",
        "url": "https://github.com/flamendless/brinevector3D",
        "description": "FFI-enabled vector library for 3D (x,y,z)"
    },
    {
        "name": "bump-3dpd",
        "author": "oniietzschan",
        "url": "https://github.com/oniietzschan/bump-3dpd",
        "description": "A 3D collision detection library for Lua."
    },
    {
        "name": "IQE",
        "author": "excessive",
        "url": "https://github.com/excessive/iqe",
        "description": "Inter-Quake Export loader (text)"
    },
    {
        "name": "IQM",
        "author": "excessive",
        "url": "https://github.com/excessive/iqm-exm",
        "description": "Inter-Quake Model loader (binary)"
    },
    {
        "name": "love-gltf",
        "author": "Alloyed",
        "url": "https://gitlab.com/Alloyed/love-gltf",
        "description": "gltf asset loader and test renderer; Supports skeletal animations and morph targets"
    },
    {
        "name": "Lovox",
        "author": "tjakka5",
        "url": "https://github.com/tjakka5/Lovox",
        "description": "Pseudo-3D library for working with voxels"
    },
    {
        "name": "g3d",
        "author": "groverburger",
        "url": "https://github.com/groverburger/g3d",
        "description": "Simple and easy 3D engine for LÖVE."
    },
    {
        "name": "model_renderer",
        "author": "xiejiangzhi",
        "url": "https://github.com/xiejiangzhi/model_renderer",
        "description": "a simple 3d model renderer for love2d"
    },
    {
        "name": "Jumper",
        "author": "Yonaba",
        "url": "https://github.com/Yonaba/Jumper",
        "description": "Grid-based pathfinding library"
    },
    {
        "name": "Lua-star",
        "author": "wesleywerner",
        "url": "https://github.com/wesleywerner/lua-star",
        "description": "Easy and pure Lua A* path finding"
    },
    {
        "name": "astar",
        "author": "xiejiangzhi",
        "url": "https://github.com/xiejiangzhi/astar",
        "description": "An other A* library. Any map(gird, point, mesh or infinite map) and support path cost."
    },
    {
        "name": "andross",
        "author": "pfirsich",
        "url": "https://github.com/pfirsich/andross",
        "description": "a Lua library for 2D skeletal/bone animations with a Löve backend"
    },
    {
        "name": "anim8",
        "author": "kikito",
        "url": "https://github.com/kikito/anim8",
        "description": "Animation library"
    },
    {
        "name": "animx",
        "author": "YoungNeer",
        "url": "https://github.com/YoungNeer/animx",
        "description": "A featureful Animation library for loading animations from XML files!"
    },
    {
        "name": "chiro",
        "author": "bjornbytes",
        "url": "https://github.com/bjornbytes/chiro",
        "description": "Convenience wrapper around [Spine](http://esotericsoftware.com)"
    },
    {
        "name": "Peachy",
        "author": "josh-perry",
        "url": "https://github.com/josh-perry/peachy",
        "description": "A parser/renderer for Aseprite animations in LÖVE"
    },
    {
        "name": "skeletor",
        "author": "pelevesque",
        "url": "https://github.com/pelevesque/skeletor",
        "description": "2D skeletal animation system"
    },
    {
        "name": "Walt",
        "author": "davisdude",
        "url": "https://github.com/davisdude/Walt",
        "description": "Animation library"
    },
    {
        "name": "Lump",
        "author": "sixFingers",
        "url": "https://github.com/sixFingers/lump",
        "description": "Adobe Flash animation runtime"
    },
    {
        "name": "lovanim",
        "author": "patrixr",
        "url": "https://github.com/patrixr/love-animation",
        "description": "A minimal stateful animation library"
    },
    {
        "name": "SYSL-Text",
        "author": "SystemLogoff",
        "url": "https://github.com/SystemLogoff/SYSL-Text",
        "description": "Text animation and automatic wrapping library based on tags"
    },
    {
        "name": "Brady",
        "author": "davisdude",
        "url": "https://github.com/davisdude/Brady",
        "description": "Camera library with parallax scrolling"
    },
    {
        "name": "Editgrid",
        "author": "bakpakin",
        "url": "https://github.com/bakpakin/Editgrid",
        "description": "Gamera and HUMP compatible scaling grid"
    },
    {
        "name": "gamera",
        "author": "kikito",
        "url": "https://github.com/kikito/gamera",
        "description": "Camera system"
    },
    {
        "name": "hump.camera",
        "author": "en",
        "url": "https://hump.readthedocs.io/en/latest/camera.html",
        "description": "Camera library with window locking and smooth camera movement interpolation"
    },
    {
        "name": "FPSGraph",
        "author": "icrawler",
        "url": "https://github.com/icrawler/FPSGraph",
        "description": "Small FPS graphing utility"
    },
    {
        "name": "debugGraph",
        "author": "Mechazawa",
        "url": "https://github.com/Mechazawa/Love-Debug-Graph",
        "description": "Small OO FPS graphing utillity based on FPSGraph"
    },
	{
		"name": "Kazari",
		"author": "Miku AuahDark",
		"url": "https://github.com/MikuAuahDark/Kazari",
		"description": "Multitouch gesture and input library."
	},
    {
        "name": "Lovebird",
        "author": "rxi",
        "url": "https://github.com/rxi/lovebird",
        "description": "Browser-based debug console"
    },
    {
        "name": "LoveDebug",
        "author": "Ranguna",
        "url": "https://github.com/Ranguna/LOVEDEBUG",
        "description": "Inline console-like debugger utility"
    },
    {
        "name": "lurker",
        "author": "rxi",
        "url": "https://github.com/rxi/lurker",
        "description": "Auto-swaps changed Lua files in a running game"
    },
    {
        "name": "LÖVE API",
        "author": "love2d-community",
        "url": "https://github.com/love2d-community/love-api",
        "description": "The complete API documentation of LÖVE in a Lua table"
    },
    {
        "name": "LÖVE Build",
        "author": "nhartland",
        "url": "https://github.com/nhartland/love-build",
        "description": "GitHub Action for automated cross-platform builds"
    },
    {
        "name": "LÖVE TypeScript Definitions",
        "author": "hazzard993",
        "url": "https://github.com/hazzard993/love-typescript-definitions",
        "description": "Write LÖVE games with TypeScript"
    },
    {
        "name": "lovelier",
        "author": "patrixr",
        "url": "https://github.com/patrixr/lovelier",
        "description": "A Love2D live reloader with Moonscript support"
    },
    {
        "name": "Artal",
        "author": "unXedDani",
        "url": "https://github.com/unXedDani/Artal",
        "description": "A .PSD parsing library for LÖVE"
    },
    {
        "name": "Autobatch",
        "author": "rxi",
        "url": "https://github.com/rxi/autobatch",
        "description": "Small LÖVE module to automate the use of SpriteBatches"
    },
    {
        "name": "center",
        "author": "S-Walrus",
        "url": "https://github.com/S-Walrus/center",
        "description": "A simple module to dynamically align and fit content to screens of any size"
    },
    {
        "name": "cindy",
        "author": "megagrump",
        "url": "https://github.com/megagrump/cindy",
        "description": "Use byte color values in LÖVE 11+"
    },
    {
        "name": "deep",
        "author": "Nikaoto",
        "url": "https://github.com/Nikaoto/deep",
        "description": "Adds Z axis; allows you to queue actions and draw calls"
    },
    {
        "name": "draft",
        "author": "pelevesque",
        "url": "https://github.com/pelevesque/draft",
        "description": "A module for drawing complex shapes"
    },
    {
        "name": "HSLUV",
        "author": "hsluv",
        "url": "https://github.com/hsluv/hsluv-lua",
        "description": "Lua implementation of HSLuv (a human-friendly alternative to HSL)"
    },
    {
        "name": "Maid64",
        "author": "adekto",
        "url": "https://github.com/adekto/maid64",
        "description": "Low resolution scaler for LÖVE"
    },
    {
        "name": "Push",
        "author": "Ulydev",
        "url": "https://github.com/Ulydev/push",
        "description": "A simple resolution-handling library for LÖVE"
    },
    {
        "name": "renderplanet",
        "author": "meric",
        "url": "https://github.com/meric/renderplanet/",
        "description": "realistic orthographic planet rendering"
    },
    {
        "name": "svglover",
        "author": "globalcitizen",
        "url": "https://github.com/globalcitizen/svglover",
        "description": "Library to import and display simple SVGs in LÖVE"
    },
    {
        "name": "SYSL-Pixel",
        "author": "SystemLogoff",
        "url": "https://github.com/SystemLogoff/Sysl-Pixel",
        "description": "Pixel art focused scaler for graphics, position, screen-captures and shaders"
    },
    {
        "name": "Sölar",
        "author": "JanWerder",
        "url": "https://github.com/JanWerder/soelar",
        "description": "a fairly simple solar system simulator"
    },
    {
        "name": "Tove2d",
        "author": "poke1024",
        "url": "https://github.com/poke1024/tove2d",
        "description": "Animated vector graphics for LÖVE"
    },
    {
        "name": "turtle.lua",
        "author": "arthurealike",
        "url": "https://github.com/arthurealike/turtle.lua",
        "description": "Turtle graphics library for LÖVE"
    },
    {
        "name": "adorbs",
        "author": "JosephShering",
        "url": "https://github.com/JosephShering/adorbs",
        "description": "Minimal, Functional Entity Component System"
    },
    {
        "name": "Concord",
        "author": "Tjakka5",
        "url": "https://github.com/Tjakka5/Concord",
        "description": "A feature-complete ECS library"
    },
    {
        "name": "knife.system",
        "author": "airstruck",
        "url": "https://github.com/airstruck/knife/blob/master/readme/system.md",
        "description": "Minimalist functional ECS"
    },
    {
        "name": "nata",
        "author": "tesselode",
        "url": "https://github.com/tesselode/nata",
        "description": "Hybrid OOP/ECS entity management"
    },
    {
        "name": "tiny-ecs",
        "author": "bakpakin",
        "url": "https://github.com/bakpakin/tiny-ecs",
        "description": "Entity Component System for Lua that's simple, flexible, and useful"
    },
    {
        "name": "astray",
        "author": "SiENcE",
        "url": "https://github.com/SiENcE/astray",
        "description": "Astray is a lua based maze, room and dungeon generation library for dungeon crawlers and roguelike video games"
    },
    {
        "name": "cartographer",
        "author": "tesselode",
        "url": "https://github.com/tesselode/cartographer",
        "description": "Small Tiled map loader and drawer."
    },
    {
        "name": "clove",
        "author": "YoungNeer",
        "url": "https://github.com/YoungNeer/clove",
        "description": "A helper library which allows you to quickly loads huge amount of assets"
    },
    {
        "name": "hump",
        "author": "vrld",
        "url": "https://github.com/vrld/hump",
        "description": "Collection of tools for developing games with LÖVE (Gamestates, Timers/Tweens, Vectors, Classes, Signals, Cameras). Repo is inactive but improvements are in the works at [this fork](https://github.com/HDictus/hump/tree/temp-master) (branch temp-master)"
    },
    {
        "name": "iffy",
        "author": "YoungNeer",
        "url": "https://github.com/YoungNeer/iffy",
        "description": "A SpriteSheet and Tileset helper library for LÖVE"
    },
    {
        "name": "knife",
        "author": "airstruck",
        "url": "https://github.com/airstruck/knife",
        "description": "Collection of useful micro-modules for Lua (Class, State Machines, Bind, Chain, Coroutines, Event, Memoize, Entity, Tests, Timer)"
    },
    {
        "name": "shard",
        "author": "MineGame159",
        "url": "https://github.com/MineGame159/shard",
        "description": "Collection of useful mini modules"
    },
    {
        "name": "lovely-windows",
        "author": "flamendless",
        "url": "https://github.com/flamendless/lovely-windows",
        "description": "A Window/Screen Manager Module for virtual windows."
    },
    {
        "name": "love-state-switcher",
        "author": "nekromoff",
        "url": "https://github.com/nekromoff/love-state-switcher",
        "description": "State switcher class for Lua LÖVE Engine"
    },
    {
        "name": "lue",
        "author": "Ulydev",
        "url": "https://github.com/Ulydev/lue",
        "description": "lue is a LÖVE library that allows you to display hue color effects in your game"
    },
    {
        "name": "narrator",
        "author": "astrochili",
        "url": "https://github.com/astrochili/narrator",
        "description": "An Ink narrative scripting language parser and runtime implementation"
    },
    {
        "name": "reflowprint",
        "author": "josefnpat",
        "url": "https://github.com/josefnpat/reflowprint",
        "description": "A library designed for alignment of text that is shown one character at a time"
    },
    {
        "name": "roomy",
        "author": "tesselode",
        "url": "https://github.com/tesselode/roomy",
        "description": "screen management library for LÖVE"
    },
    {
        "name": "rotLove",
        "author": "paulofmandown",
        "url": "https://github.com/paulofmandown/rotLove",
        "description": "Roguelike Toolkit in Love. A Love2D/lua port of rot.js"
    },
    {
        "name": "ScreenManager",
        "author": "rm-code",
        "url": "https://github.com/rm-code/screenmanager",
        "description": "Screen/State Management for the LÖVE framework"
    },
    {
        "name": "shack",
        "author": "Ulydev",
        "url": "https://github.com/Ulydev/shack",
        "description": "shack is a LÖVE library that lets you easily add screen effects such as shake and rotation"
    },
    {
        "name": "Simple Tiled Implementation",
        "author": "karai17",
        "url": "https://github.com/karai17/Simple-Tiled-Implementation",
        "description": "Tiled map loader and renderer"
    },
    {
        "name": "Vivid",
        "author": "WetDesertRock",
        "url": "https://github.com/WetDesertRock/vivid",
        "description": "Color math, manipulation and conversion library"
    },
    {
        "name": "Yonder",
        "author": "thenerdie",
        "url": "https://github.com/thenerdie/Yonder",
        "description": "A ridiculously easy to use game state management library for LOVE2D"
    },
    {
        "name": "baton",
        "author": "tesselode",
        "url": "https://github.com/tesselode/baton",
        "description": " Input library for LÖVE that bridges the gap between keyboard and gamepad controls"
    },
    {
        "name": "input",
        "author": "xiejiangzhi",
        "url": "https://github.com/xiejiangzhi/input",
        "description": " Simple and powerful input library. support check operation time, sequence."
    },
    {
        "name": "love-microphone",
        "author": "LPGhatguy",
        "url": "https://github.com/LPGhatguy/love-microphone",
        "description": "Simple microphone support for LÖVE"
    },
    {
        "name": "LoveKeys",
        "author": "SpaceCat-Chan",
        "url": "https://github.com/SpaceCat-Chan/LoveKeys",
        "description": "A simple input handeling library that keeps track of things for you"
    },
    {
        "name": "tactile",
        "author": "tesselode",
        "url": "https://github.com/tesselode/tactile",
        "description": "A straightforward and flexible input library"
    },
    {
        "name": "lighter",
        "author": "speakk",
        "url": "https://github.com/speakk/lighter",
        "description": "A performant dynamic light implementation with a simple API"
    },
    {
        "name": "Shädows",
        "author": "matiasah",
        "url": "https://github.com/matiasah/shadows",
        "description": "A Shadows & Lights engine for löve"
    },
    {
        "name": "Light World",
        "author": "tanema",
        "url": "https://github.com/tanema/light_world.lua",
        "description": "A lighting model"
    },
    {
        "name": "Simple Love Lights",
        "author": "dylhunn",
        "url": "https://github.com/dylhunn/simple-love-lights",
        "description": "A very simple raycasting light implementation"
    },
    {
        "name": "Light",
        "author": "xiejiangzhi",
        "url": "https://github.com/xiejiangzhi/light",
        "description": "A simple dynamic light implementation"
    },
    {
        "name": "Bresenham",
        "author": "rm-code",
        "url": "https://github.com/rm-code/Bresenham",
        "description": "Bresenham's line algorithm written in Lua"
    },
    {
        "name": "brinevector",
        "author": "novemberisms",
        "url": "https://github.com/novemberisms/brinevector",
        "description": "Standalone lightweight luajit ffi-accelerated 2D vector library for great performance"
    },
    {
        "name": "Cirno's Perfect Math Library",
        "author": "excessive",
        "url": "https://github.com/excessive/cpml",
        "description": "Math/intersection library designed for games"
    },
    {
        "name": "delaunay",
        "author": "Yonaba",
        "url": "https://github.com/Yonaba/delaunay",
        "description": "Delaunay triangulation for convex polygons"
    },
    {
        "name": "hump.vector",
        "author": "en",
        "url": "https://hump.readthedocs.io/en/latest/vector.html",
        "description": "Powerful 2D vector class"
    },
    {
        "name": "MLib",
        "author": "davisdude",
        "url": "https://github.com/davisdude/mlib",
        "description": "Math and shape-intersection detection library written in Lua. It's aim is to be robust and easy to use"
    },
    {
        "name": "nvec",
        "author": "MikuAuahDark",
        "url": "https://github.com/MikuAuahDark/NPad93/blob/master/nvec.lua",
        "description": "hump.vector-compatible LuaJIT FFI-accelerated 2D vector library"
    },
    {
        "name": "shash",
        "author": "rxi",
        "url": "https://github.com/rxi/shash",
        "description": "A simple, lightweight spatial hash for Lua"
    },
    {
        "name": "vector.lua",
        "author": "themousery",
        "url": "https://github.com/themousery/vector.lua",
        "description": "a simple vector library based on the PVector class from processing"
    },
    {
        "name": "denver",
        "author": "superzazu",
        "url": "https://github.com/superzazu/denver.lua",
        "description": "A Löve custom waveform generation library"
    },
    {
        "name": "lovebpm",
        "author": "rxi",
        "url": "https://github.com/rxi/lovebpm",
        "description": "A LÖVE library for syncing events to the BPM of an audio track"
    },
    {
        "name": "ripple",
        "author": "tesselode",
        "url": "https://github.com/tesselode/ripple",
        "description": "An audio manager with tagging support"
    },
    {
        "name": "wave",
        "author": "Ulydev",
        "url": "https://github.com/Ulydev/wave",
        "description": "A sound manager with audio parsing and rhythm functionalities"
    },
    {
        "name": "Grease",
        "author": "bartbes",
        "url": "https://github.com/bartbes/love-misc-libs/tree/master/grease",
        "description": "Networking library intended to make networking easy for lovers (TCP, UDP, Enet)  [IPv6]"
    },
    {
        "name": "LoverNet",
        "author": "josefnpat",
        "url": "https://github.com/josefnpat/LoverNet",
        "description": "A networking library that leverages bitser and enet [IPv4]"
    },
	{
		"name": "NAniTe",
		"author": "Miku AuahDark",
		"url": "https://github.com/MikuAuahDark/NPad93#nanite",
		"description": "Timeline-based animation system that supports forward and backward update."
	},
    {
        "name": "NoobHub",
        "author": "Overtorment",
        "url": "https://github.com/Overtorment/NoobHub",
        "description": "OpenSource multiplayer and network messaging [IPv6]"
    },
    {
        "name": "NLay",
        "author": "MikuAuahDark",
        "url": "https://github.com/MikuAuahDark/NPad93/blob/master/nlay.lua",
        "description": "NLay is layouting library inspired by the flexibility of Android's ConstraintLayout.",
        "api": [
            {
                "name": "inside",
                "arguments": "constraint [, padding]",
                "description": "Create new `Inside` object (constraint with padding information), used to construct `Constraint` object later.",
                "example": "local inRoot = NLay.inside(NLay)"
            },
            {
                "name": "update",
                "arguments": "x, y, w, h",
                "description": "Update the root constraint dimensions.",
                "example": "NLay.update(love.window.getSafeArea())"
            },
            {
                "name": "max",
                "arguments": "...",
                "description": "Create new constraint whose the size and the position is based on bounding box of the other constraints.",
                "example": "local maxConstraint = NLay.max(con1, con2, con3, con4)"
            },
            {
                "name": "line",
                "arguments": "constraint, direction, measurement, value",
                "description": "Create new guideline constraint.",
                "example": "local guideline = NLay.line(NLay, \"horizontal\", \"percent\", 0.25)"
            },
			{
				"name": "batchGet",
				"argument": "...",
				"description": "Performs batched retrieval of constraint values, improves performance when resolving different constraints with identical attached constraints.",
				"example": "local c = NLay.batchGet(constraint1, constraint2, constraint3)\n\nfor i = 1, #c, 4 do\n\tlove.graphics.rectangle(\"fill\", c[i], c[i+1], c[i+2], c[i+3])\nend"
			},
			{
				"name": "grid",
				"argument": "constraint, nrows, ncols [, settings]",
				"description": "Create new grid layout (`Grid` object) using the `constraint` constraint as the base.",
				"example": "local grid = NLay.grid(constraint, 4, 4, {spacing = 4}) -- default dynamic grid cell size\nlocal grid = NLay.grid(constraint, 4, 4, {\n\t-- Activates fixed mode by specifying cell dimensions.\n\tcellWidth = 64,\n\tcellHeight = 64\n})"
			},
            {
                "name": "Inside:constraint",
                "arguments": "top, left, bottom, right",
                "description": "Create new `Constraint` object. At least contain 1 horizontal and 1 vertical constraints is required.",
                "example": "local topRightAlignConstraint = inRoot:constraint(NLay, nil, nil, NLay)"
            },
            {
                "name": "BaseConstraint:get",
                "arguments": "[offx [, offy]]",
                "description": "Retrieve the positions and the dimensions of constraint.",
                "example": "love.graphics.rectangle(\"fill\", constraint:get())"
            },
            {
                "name": "Constraint:into",
                "arguments": "top, left, bottom, right",
                "description": "This function tells to NOT use the opposite sides of the constraint for constraint at top, left, bottom, and/or right.",
                "example": "local constraint = inRoot:constraint(base, base):into(false, true)"
            },
            {
                "name": "Constraint:margin",
                "arguments": "margin",
                "description": "Sets the constraint margin.",
                "example": "constraint:margin(10) -- sets margin for all sides\nconstraint:margin({10, 0, 0, 10}) -- sets margin for top right sides"
            },
            {
                "name": "Constraint:size",
                "arguments": "width, height [, modeW [, modeH]]",
                "description": "Sets the constraint width and height.",
                "example": "constraint:size(48, 48) -- fixed size\nconstraint:size(0, 48) -- width is calculated from left and right constraint"
            },
            {
                "name": "Constraint:bias",
                "arguments": "horizontal, vertical [, unclamped]",
                "description": "Set the constraint bias.",
                "example": "constraint:bias(0.5, 0.75) -- places the constraint at horizontal center and 3/4 vertical"
            },
            {
                "name": "Constraint:forceIn",
                "arguments": "force",
                "description": "**Niche-case function!** Force the \"into\" flags to be determined by user even if it may result as invalid constraint."
            },
            {
                "name": "Constraint:tag",
                "arguments": "data",
                "description": "Tag this constraint with user-specific data."
            },
            {
                "name": "Constraint:getTag",
                "arguments": "",
                "description": "Retrieve tag data previously set from constraint."
            },
			{
				"name": "LineConstraint:offset",
				"arguments": "off",
				"description": "(Re)-set the line offset previously set from `NLay.line`"
			},
			{
				"name": "Grid:get",
				"arguments": "row, column",
				"description": "Retrieve `GridCellConstraint` at specified row and column. `GridCellConstraint` implements `BaseConstraint`.",
				"example": "local topleft = grid:get(1, 1)"
			},
			{
				"name": "Grid:spacing",
				"arguments": "horizontal, vertical [, horizontalFL [, verticalFL]]",
				"description": "Change the spacing of each cell.",
				"example": "grid:spacing(4, 4)\ngrid:spacing(4, 4, true, true) -- adds padding to first and last row and column."
			},
			{
				"name": "Grid:cellSize",
				"arguments": "width, height",
				"description": "Set the cell size of the grid, excluding spacing. This function only takes effect on fixed mode, otherwise it does nothing."
			},
			{
				"name": "Grid:foreach",
				"arguments": "func",
				"description": "Call a function for each `GridCellConstraint` in the grid.",
				"example": "grid:foreach(function(constraint, row, col)\n\t-- Do something to constraint at specified rows and columns\nend)"
			},
			{
				"name": "Grid:isFixed",
				"arguments": "",
				"description": "Is the grid in dynamic mode or fixed mode?",
				"example": "print(grid:isFixed() and \"fixed mode\" or \"dynamic mode\")"
			},
			{
				"name": "Grid:getCellDimensions",
				"arguments": "",
				"description": "Retrieve the dimensions of a single cell.",
				"example": "local cw, ch = grid:getCellDimensions()"
			}
        ]
    },
    {
        "name": "Sock.lua",
        "author": "camchenry",
        "url": "https://github.com/camchenry/sock.lua",
        "description": "A Lua networking library for LÖVE games [IPv4]"
    },
    {
        "name": "löve-ws",
        "author": "holywyvern",
        "url": "https://github.com/holywyvern/love-ws",
        "description": "A websocket client and server library"
    },
    {
        "name": "love2d-lua-websocket",
        "author": "flaribbit",
        "url": "https://github.com/flaribbit/love2d-lua-websocket",
        "description": "A simple event-driven websocket client library [IPv4]"
    },
    {
        "name": "lua-https",
        "author": "LÖVE Development Team",
        "url": "https://github.com/love2d/lua-https",
        "description": "A simple Lua HTTPS module using native platform backends where applicable.",
        "api": [
            {
                "name": "https.request",
                "arguments": "url [, options]",
                "description": "Perform HTTP/HTTPS request on specified URL.",
                "example": "local code, body, headers = https.request(\"https://httpbin.org/get\", {method = \"get\"})"
            }
        ]
    },
    {
        "name": "30log",
        "author": "Yonaba",
        "url": "https://github.com/Yonaba/30log",
        "description": "Minified framework for object-orientation in Lua. It features named (and unnamed) classes, single inheritance and a basic support for mixins"
    },
    {
        "name": "classic",
        "author": "rxi",
        "url": "https://github.com/rxi/classic/",
        "description": "Tiny class module for Lua. Attempts to stay simple and provide decent performance by avoiding unnecessary over-abstraction"
    },
    {
        "name": "hump.class",
        "author": "en",
        "url": "https://hump.readthedocs.io/en/latest/class.html",
        "description": "Small, fast class/prototype implementation with multiple inheritance (class-commons)"
    },
    {
        "name": "knife.base",
        "author": "airstruck",
        "url": "https://github.com/airstruck/knife/blob/master/readme/base.md",
        "description": "Extremely minimal base class providing single inheritance and constructors."
    },
    {
        "name": "middleclass",
        "author": "kikito",
        "url": "https://github.com/kikito/middleclass",
        "description": "Simple OOP library for Lua; has inheritance, metamethods (operators), class variables and weak mixin support (class-commons)"
    },
    {
        "name": "muun",
        "author": "megagrump",
        "url": "https://github.com/megagrump/muun",
        "description": "Moonscript compatible class implementation"
    },
    {
        "name": "selene",
        "author": "novafacing",
        "url": "https://github.com/novafacing/selene",
        "description": "Project template for writing games in Moonscript instead of Lua without precompiling"
    },
    {
        "name": "jprof",
        "author": "pfirsich",
        "url": "https://github.com/pfirsich/jprof",
        "description": "Profiling library/tool for LÖVE"
    },
    {
        "name": "Piefiller",
        "author": "Polynominal",
        "url": "https://github.com/Polynominal/Piefiller",
        "description": "Graphical profiler for LÖVE"
    },
    {
        "name": "profile.lua",
        "author": "itraykov",
        "url": "https://bitbucket.org/itraykov/profile.lua/src/",
        "description": "Profile.lua is a small, non-intrusive module for finding bottlenecks in your Lua code"
    },
    {
        "name": "ProFi",
        "author": "rm-code",
        "url": "https://gist.github.com/rm-code/383c98a6af04652ed9f39b7ae536bcc5",
        "description": "A simple lua profiler that works with LuaJIT and prints a pretty report file in columns"
    },
    {
        "name": "breezefield",
        "author": "HDictus",
        "url": "https://github.com/HDictus/breezefield",
        "description": "A lightweight and easy love.physics wrapper"
    },
    {
        "name": "Bump",
        "author": "kikito",
        "url": "https://github.com/kikito/bump.lua",
        "description": "Collision detection library for Lua"
    },
    {
        "name": "HC",
        "author": "en",
        "url": "https://hc.readthedocs.io/en/latest/",
        "description": "Collision detection with arbitrary polygons; allows rotation of objects"
    },
    {
        "name": "loveblobs",
        "author": "exezin",
        "url": "https://github.com/exezin/loveblobs",
        "description": "A softbody library with support for both dynamic and static arbitrary softbodies."
    },
    {
        "name": "LoveDos",
        "author": "rxi",
        "url": "https://github.com/rxi/lovedos",
        "description": "A Lua framework for 2D DOS games, implementing a subset of the LÖVE API"
    },
    {
        "name": "LoveFTW",
        "author": "T-BoneISS",
        "url": "https://bitbucket.org/T-BoneISS/l-veftw",
        "description": "Work-in-progress port to Windows phone 8.1"
    },
    {
        "name": "LovePotion",
        "author": "TurtleP",
        "url": "https://github.com/TurtleP/LovePotion",
        "description": "Unofficial work-in-progress implementation of the LÖVE API for Nintendo 3DS and Nintendo Switch Homebrew"
    },
    {
        "name": "LOVE-WrapLua",
        "author": "LukeZGD",
        "url": "https://github.com/LukeZGD/LOVE-WrapLua",
        "description": "A small and simple wrapper for OneLua, lpp-vita, and Lua Player PS3"
    },
    {
        "name": "Love.js",
        "author": "Davidobot",
        "url": "https://github.com/Davidobot/love.js",
        "description": "LÖVE ported to the web using Emscripten"
    },
    {
        "name": "LÖVR",
        "author": "bjornbytes",
        "url": "https://github.com/bjornbytes/lovr",
        "description": "LÖVE for virtual reality devices"
    },
    {
        "name": "Love-Snap-Template",
        "author": "popey",
        "url": "https://github.com/popey/love-snap-template",
        "description": "A template for packaging LÖVE games for distribution in the Snappy Store"
    },
    {
        "name": "AppImageKit",
        "author": "AppImage",
        "url": "https://github.com/AppImage/AppImageKit",
        "description": "Using AppImageKit you can package LÖVE games as AppImages that run on common Linux-based operating systems, such as RHEL, CentOS, Ubuntu, Fedora, debian and derivatives; one game = one file"
    },
    {
        "name": "binser",
        "author": "bakpakin",
        "url": "https://github.com/bakpakin/binser",
        "description": "Customizable Lua Serializer"
    },
    {
        "name": "bitser",
        "author": "gvx",
        "url": "https://github.com/gvx/bitser",
        "description": "Serializes and deserializes Lua values with LuaJIT"
    },
    {
        "name": "cdata",
        "author": "excessive",
        "url": "https://github.com/excessive/cdata",
        "description": "Serialize between Lua data and C data using LuaJIT's FFI"
    },
    {
        "name": "knife.serialize",
        "author": "airstruck",
        "url": "https://github.com/airstruck/knife/blob/master/readme/serialize.md",
        "description": "Serialize data as a Lua script"
    },
    {
        "name": "Lady",
        "author": "gvx",
        "url": "https://github.com/gvx/Lady",
        "description": "Saving and loading savegames; based on Ser"
    },
    {
        "name": "moonblob",
        "author": "megagrump",
        "url": "https://github.com/megagrump/moonblob",
        "description": "Binary serialization and data parsing library"
    },
    {
        "name": "Ser",
        "author": "gvx",
        "url": "https://github.com/gvx/Ser",
        "description": "Fast, robust, richly-featured table serialization library for Lua"
    },
    {
        "name": "Smallfolk",
        "author": "gvx",
        "url": "https://github.com/gvx/Smallfolk",
        "description": "A fast, robust, secure, richly-featured table serialization library for Lua"
    },
    {
        "name": "trickle",
        "author": "bjornbytes",
        "url": "https://github.com/bjornbytes/trickle",
        "description": "A bitstream library focused on high compression for use in networking"
    },
    {
        "name": "LoveShaderConverter",
        "author": "tsteinholz",
        "url": "https://github.com/tsteinholz/LoveShaderConverter",
        "description": "Convert Shadertoy Shader files to LÖVE GLSL Files with handy utilities for infinite purposes"
    },
    {
        "name": "Moonshine",
        "author": "vrld",
        "url": "https://github.com/vrld/moonshine",
        "description": "Repository of common post-processing effects like blur, vignette, color-grading, etc."
    },
    {
        "name": "busted",
        "author": "Olivine-Labs",
        "url": "https://github.com/Olivine-Labs/busted",
        "description": "Simple unit-testing framework with customizable assertions"
    },
    {
        "name": "knife.test",
        "author": "airstruck",
        "url": "https://github.com/airstruck/knife/blob/master/readme/test.md",
        "description": "Fixture-free test framework"
    },
    {
        "name": "Luassert",
        "author": "Olivine-Labs",
        "url": "https://github.com/Olivine-Labs/luassert",
        "description": "Extends `assert()` with additional, customizable tests"
    },
    {
        "name": "Lunatest",
        "author": "silentbicycle",
        "url": "https://github.com/silentbicycle/lunatest",
        "description": "xUnit-style randomized unit testing framework"
    },
    {
        "name": "lust",
        "author": "bjornbytes",
        "url": "https://github.com/bjornbytes/lust",
        "description": "Minimal test framework"
    },
    {
        "name": "Specl",
        "author": "gvvaughan",
        "url": "http://gvvaughan.github.io/specl/",
        "description": "Behavior Driven Development (BDD) tool"
    },
    {
        "name": "Telescope",
        "author": "telescope",
        "url": "http://norman.github.io/telescope/",
        "description": "Highly-customizable BDD-style testing library"
    },
    {
        "name": "Flux",
        "author": "rxi",
        "url": "https://github.com/rxi/flux",
        "description": "A fast, lightweight tweening library for Lua"
    },
    {
        "name": "hump.timer",
        "author": "en",
        "url": "https://hump.readthedocs.io/en/latest/timer.html",
        "description": "Timer and tweening library with flexible tweening methods"
    },
    {
        "name": "knife.timer",
        "author": "airstruck",
        "url": "https://github.com/airstruck/knife/blob/master/readme/timer.md",
        "description": "Create timers and tweens with ease."
    },
    {
        "name": "tick",
        "author": "rxi",
        "url": "https://github.com/rxi/tick",
        "description": "Lua module for delaying function calls"
    },
    {
        "name": "tween.lua",
        "author": "kikito",
        "url": "https://github.com/kikito/tween.lua",
        "description": "Tweening/Easing/Interpolating functions for Lua inspired on jQuery's animate method"
    },
    {
        "name": "CatUI",
        "author": "wilhantian",
        "url": "https://github.com/wilhantian/catui",
        "description": "A very light-weight GUI library for LÖVE"
    },
    {
        "name": "GOOi",
        "author": "tavuntu",
        "url": "https://github.com/tavuntu/gooi",
        "description": "Android-oriented GUI library"
    },
    {
        "name": "Gspöt",
        "author": "pgimeno",
        "url": "https://notabug.org/pgimeno/Gspot",
        "description": "A stateful GUI lib for LÖVE"
    },
    {
        "name": "Hanker",
        "author": "Alloyed",
        "url": "https://gitlab.com/Alloyed/hanker",
        "description": "Maximalist immediate mode-ish UI elements; gamepad-friendly"
    },
    {
        "name": "LoveFrames Fork",
        "author": "linux-man",
        "url": "https://github.com/linux-man/LoveFrames",
        "description": "11.2 Fork of a GUI library"
    },
    {
        "name": "Love Imgui",
        "author": "slages",
        "url": "https://github.com/slages/love-imgui",
        "description": "imgui module for the LÖVE game engine"
    },
    {
        "name": "Löve-Nuklear",
        "author": "keharriso",
        "url": "https://github.com/keharriso/love-nuklear",
        "description": "Lightweight immediate mode GUI for LÖVE games"
    },
    {
        "name": "Patchy",
        "author": "excessive",
        "url": "https://github.com/excessive/patchy",
        "description": "9patch library"
    },
    {
        "name": "Polywell",
        "author": "technomancy",
        "url": "https://gitlab.com/technomancy/polywell",
        "description": "A highly-configurable text editor / coding tool written in Lua that runs on the LÖVE game engine."
    },
    {
        "name": "SafeWord",
        "author": "josefnpat",
        "url": "https://github.com/josefnpat/safeword",
        "description": "An overscan detection library for LÖVE"
    },
    {
        "name": "Slab",
        "author": "coding-jackalope",
        "url": "https://github.com/coding-jackalope/Slab",
        "description": "Slab is an immediate mode GUI toolkit for the LÖVE framework."
    },
    {
        "name": "SUIT",
        "author": "vrld",
        "url": "https://github.com/vrld/SUIT",
        "description": "small immediate mode GUI library"
    },
    {
        "name": "ListBox",
        "author": "darkmetalic",
        "url": "https://github.com/darkmetalic/ListBox",
        "description": "A dynamic ListBox for LÖVE that supports touch, mouse, and keyboard inputs"
    },
    {
        "name": "Lynx",
        "author": "TSnake41",
        "url": "https://gitlab.com/TSnake41/lynx",
        "description": "Very-lightweight list-based UI library."
    },
    {
        "name": "YALG",
        "author": "sasszem",
        "url": "https://github.com/sasszem/yalg",
        "description": "A very simple, cross-platform, reactive UI for last minute UIs."
    },
    {
        "name": "Helium",
        "author": "qeffects",
        "url": "https://github.com/qeffects/helium",
        "description": "A modern, customizable, high performance retained UI framework."
    },
    {
        "name": "ArrayRotation",
        "author": "rm-code",
        "url": "https://gist.github.com/rm-code/4118d4a97d8cde16952199d94b84ead0",
        "description": "Rotation of two dimensional arrays (square and non-square)"
    },
    {
        "name": "cargo",
        "author": "bjornbytes",
        "url": "https://github.com/bjornbytes/cargo",
        "description": "Asset manager"
    },
    {
        "name": "chance.lua",
        "author": "ejmr",
        "url": "http://ejmr.github.io/chance.lua/",
        "description": "Library for generating random data"
    },
    {
        "name": "colorchanger",
        "author": "santoslove",
        "url": "https://github.com/santoslove/colorchanger",
        "description": "Change the colors in your LÖVE game"
    },
    {
        "name": "Flirt",
        "author": "Alloyed",
        "url": "https://github.com/Alloyed/flirt",
        "description": "LÖVE version manager; allows to switch between multiple versions of engine on same machine"
    },
    {
        "name": "GifCat",
        "author": "WetDesertRock",
        "url": "https://github.com/WetDesertRock/GifCat",
        "description": "A simple module for saving gifs from LÖVE"
    },
    {
        "name": "hex2color",
        "author": "S-Walrus",
        "url": "https://github.com/S-Walrus/hex2color/",
        "description": "A single function to use HEX color values"
    },
    {
        "name": "i18n",
        "author": "excessive",
        "url": "https://github.com/excessive/i18n",
        "description": "Internationalization library designed to help localize your game"
    },
    {
        "name": "Ini Parser",
        "author": "FivosM",
        "url": "https://github.com/FivosM/ini_parser",
        "description": "General purpose ini configuration parser"
    },
    {
        "name": "log.lua",
        "author": "rxi",
        "url": "https://github.com/rxi/log.lua",
        "description": "Library for configurable log output"
    },
    {
        "name": "love-loader",
        "author": "kikito",
        "url": "https://github.com/kikito/love-loader",
        "description": "Threaded resource loading"
    },
    {
        "name": "love2d-assets-loader",
        "author": "Yonaba",
        "url": "https://github.com/Yonaba/love2d-assets-loader",
        "description": "Assets Loader"
    },
    {
        "name": "love-pe",
        "author": "RamiLego4Game",
        "url": "https://github.com/RamiLego4Game/love-pe",
        "description": "A tool made in LÖVE for changing LÖVE icon itself"
    },
    {
        "name": "lovely-engine",
        "author": "vinnyhorgan",
        "url": "https://github.com/vinnyhorgan/lovely-engine",
        "description": "A tool that makes setting up and using Love2d easier and with Moonscript support"
    },
    {
        "name": "Lily",
        "author": "MikuAuahDark",
        "url": "https://github.com/MikuAuahDark/lily",
        "description": "Async Asset Loader"
    },
    {
        "name": "luasteam",
        "author": "uspgamedev",
        "url": "https://github.com/uspgamedev/luasteam",
        "description": "Lua bindings for the Steamworks API"
    },
    {
        "name": "Luvent",
        "author": "ejmr",
        "url": "https://github.com/ejmr/Luvent",
        "description": "Simple event-driven programming"
    },
    {
        "name": "nativefiledialog",
        "author": "Alloyed",
        "url": "https://github.com/Alloyed/nativefiledialog/tree/master/lua",
        "description": "Open a file picker on Windows/Mac/Linux"
    },
    {
        "name": "nativefs",
        "author": "megagrump",
        "url": "https://github.com/megagrump/nativefs",
        "description": "Read and write files outside of LÖVE's allowed paths"
    },
    {
        "name": "ngrading",
        "author": "MikuAuahDark",
        "url": "https://github.com/MikuAuahDark/NPad93/tree/master/ngrading",
        "description": "NPad Color Grading, provides easy color grading for your post-processing needs.",
        "api": [
            {
                "name": "load",
                "arguments": "image, pixelsPerCell",
                "description": "Create new `ColorGrading` object from specified RGB lookup-table."
            },
            {
                "name": "getShader",
                "arguments": "",
                "description": "Get the internal shader string used for the color grading effect."
            },
            {
                "name": "ColorGrading:apply",
                "arguments": "",
                "description": "Set the shader to color grading shader. Any subsequent drawing will use the color grading shader."
            },
            {
                "name": "ColorGrading:setupShaderData",
                "arguments": "[shader]",
                "description": "Prepares the specified (or active) shader to apply color grading data."
            }
        ]
    },
    {
        "name": "ParticleEditor",
        "author": "MusouCrow",
        "url": "https://github.com/MusouCrow/ParticleEditor",
        "description": "An editor of particle for LÖVE"
    },
    {
        "name": "particle-system-playground",
        "author": "santoslove",
        "url": "https://github.com/santoslove/particle-system-playground",
        "description": "A basic LÖVE particle system editor"
    },
    {
        "name": "splashy",
        "author": "videah",
        "url": "https://github.com/videah/splashy",
        "description": "Splash Screen Library"
    },
    {
        "name": "ShakeDetectorLua",
        "author": "azoyan",
        "url": "https://github.com/azoyan/ShakeDetectorLua",
        "description": "uses accelerometer data for shake device detection written in Lua"
    },
    {
        "name": "tick",
        "author": "bjornbytes",
        "url": "https://github.com/bjornbytes/tick",
        "description": "Useful timing tweaks for LÖVE's run loop"
    },
    {
        "name": "plan",
        "author": "zombrodo",
        "url": "https://github.com/zombrodo/plan",
        "description": "A super simple layout helper, designed for use with Love2d"
    },
    {
        "name": "urutora",
        "author": "tavuntu",
        "url": "https://github.com/tavuntu/urutora",
        "description": "GUI Library for LÖVE"
    },
    {
        "name": "TVec",
        "author": "FlamingArr",
        "url": "https://github.com/FlamingArr/TVec",
        "description": "Pooled, FFI-ed Vector library for Lua"
    },
    {
        "name": "makelove",
        "author": "pfirsch",
        "url": "https://github.com/pfirsich/makelove",
        "description": "A build tool for löve games"
    },
    {
        "name": "ferris",
        "author": "1bardesign",
        "url": "https://github.com/1bardesign/ferris/",
        "description": "A love2d sort-of-ecs system and some other gamey utilities to get."
    },
    {
        "name": "Runtime Texture Atlas (RTA)",
        "author": "EngineerSmith",
        "url": "https://github.com/EngineerSmith/Runtime-TextureAtlas",
        "description": "Texture atlas packer and renderer at runtime; no external tools.",
        "api": [
            {
                "name": "RTA.newFixedSize",
                "arguments": "width, [height = width], [padding = 1], [extrude = 0], [spacing = 0]",
                "description": "Create a fixed sized texture atlas; for a specific sized image",
                "example": "atlas = RTA.newFixedSize(32, 32, 0, 1, 0)\natlas = RTA.newFixedSize(32, 64)"
            },
            {
                "name": "RTA.newDynamicSize",
                "arguments": "[padding = 1], [extrude = 0], [spacing = 0]",
                "description": "Create a dynamic sized texture atlas; for any sized image",
                "example": "atlas = RTA.newDynamicSize(0, 1, 0)\natlas = RTA.newDynamicSize()"
            },
            {
                "name": "atlas:useImageData",
                "arguments": "[boolean = false]",
                "description": "Change mode for the atlas to use imageData instead of love.graphics; useful for headless versions of love.\nYou cannot change this setting after adding images to the texture atlas!",
                "example": "atlas:useImageData(true)"
            },
            {
                "name": "atlas:setFilter",
                "arguments": "min, [max = min]",
                "description": "Change filter used for the atlas; this will always override the default filter even if not changed",
                "example": "atlas:setFilter(\"nearest\")\natlas:setFilter(\"nearest\", \"nearest\")"
            },
            {
                "name": "atlas:setBakeAsPow2",
                "arguments": "[boolean = false]",
                "description": "Will round the width and height to the nearest power of 2 value. Warning, packing algorithms are not optimized for spacing towards the closest power of 2 and will just pad.",
                "example": "atlas:setBakeAsPow2(true)"
            },
            {
                "name": "atlas:setPadding",
                "arguments": "padding",
                "description": "Set the padding around each image; this will push the image away from the edge of the atlas.",
                "example": "atlas:setPadding(4)\natlas:setPadding(1)"
            },
            {
                "name": "atlas:setExtrude",
                "arguments": "extrude",
                "description": "Set the amount the image is extruded by; this will use the warp mode set for the image. Unless the atlas is in imageData mode then it will use clamp.",
                "example": "atlas:setExtrude(6)\natlas:setExtrude(1)"
            },
            {
                "name": "atlas:setSpacing",
                "arguments": "spacing",
                "description": "Set spacing between each image; does not add spacing between images and the edge of the atlas",
                "example": "atlas:setSpacing(3)\natlas:setSpacing(1)"
            },
            {
                "name": "atlas:setMaxSize",
                "arguments": "[width = systemMax], [height = systemMax]",
                "description": "Sets the maximum size for the texture atlas. Default is the current system limits unless in imageData mode then it is 16,384",
                "example": "atlas:setMaxSize(1000, 1000)\natlas:setMaxSize(100) -- height becomes system limit\natlas:setMaxSize(nil, 100) -- width becomes system limit"
            },
            {
                "name": "atlas:add",
                "arguments": "image, id, [bake = false], [...]",
                "description": "Add or replace an image to the atlas. Image can be either image or imageData depending on the mode set for the atlas (default image). ID can be any table index, not just numbers or strings. Use 3rd argument to bake change; recommended only bake when all changes have been made. 4th argument is passed into atlas:bake, useful for specifying sorting algorithm for dynamic atlases",
                "example": "atlas:add(love.graphics.newImage(\"duck.png\", \"duck\"))\natlas:add(love.image.newImageData(\"duck.png\"), \"duck\")"
            },
            {
                "name": "atlas:remove",
                "arguments": "id, [bake = false], [...]",
                "description": "Remove image added to atlas. Use 2rd argument to bake change; recommended only bake when all changes have been made. 3rd argument is passed into atlas:bake, useful for specifying sorting algorithm for dynamic atlases",
                "example": "atlas:remove(\"duck\")"
            },
            {
                "name": "atlas:getViewport",
                "arguments": "id",
                "description": "Get viewport for given id; returns position, width and height for it's location on the texture atlas. Useful for getting the location for a mesh's uvs.",
                "example": "x, y, w, h = atlas:getViewport(\"duck\")"
            },
            {
                "name": "atlas:bake",
                "arguments": "[sortby = \"area\"]",
                "description": "Bake the texture atlas; sortby is only used by dynamic atlases. Options: area, height, width, none\nNote, it's recommended to use atlas:hardBake once all changes have been made.",
                "example": "atlas:bake()\natlas:bake(\"height\")\natlas:bake(\"area\")"
            },
            {
                "name": "atlas:hardBake",
                "arguments": "[sortby = \"area\"]",
                "description": "Hard bake the atlas; this will bake and remove all internal references to the added images. You won't be able to change the settings of the atlas after this point.",
                "example": "atlas:hardBake()\natlas:hardBake(\"width\")"
            },
            {
                "name": "atlas:draw",
                "arguments": "id, [...]",
                "description": "Draw the given id; arguments passed after id is given to love.graphics.draw",
                "example": "atlas:draw(\"duck\", 50, 50, 0, 2, 2)\natlas:draw(\"duck\")"
            },
            {
                "name": "atlas:getDrawFuncForID",
                "arguments": "id",
                "description": "Get a drawing function for a given id to avoid padding around the atlas and the id around, and just pass a function instead.",
                "example": "local duckDrawFunc = atlas:getDrawFuncForID(\"duck\")\nduckDrawFunc(50, 50, 0, 2, 2)"
            }
        ]
    },
    {
        "name": "AppleCake",
        "author": "EngineerSmith",
        "url": "https://github.com/EngineerSmith/AppleCake",
        "description": "Profiling library with detailed tools and thread support.",
        "api": [
            {
                "name": "beginSession",
                "arguments": "[filepath = \"profile.json\"], [name = love.filesystem.getIdentity()]",
                "description": "Starts the profiling session by opening the mentioned file, and names the process and current thread with the 2nd argument",
                "example": "AppleCake.beginSession() -- Creates profile.json in save directory, using the filesystem identity as the processes name\nAppleCake.beginSession(\"profile-server.json\", \"game-server\")"
            },
            {
                "name": "endSession",
                "description": "Close the current session and wait for write thread to rejoin this thread. If buffer is enabled, it will flush before ending the session.",
                "example": "AppleCake.endSession()"
            },
            {
                "name": "enable",
                "arguments": "[levels = \"all\"]",
                "description": "Enable or disable profiling tools in certain parts of the code.\nSee AppleCake own docs for more details and examples.",
                "example": "AppleCake.enable(\"all\")\nAppleCake.enable(\"none\")\nappleCake.enable(\"profile\") -- only enable profiles\nappleCake.enable(\"mark\") -- only enable marks\nappleCake.enable(\"counter\") -- only enable counters"
            },
            {
                "name": "profile",
                "arguments": "name, [args], [profile]",
                "description": "Profile a section of code over time.",
                "example": "local profile\nfunction love.update(dt)\n  profile = AppleCake.profile(\"update\", {deltaTime=dt}, profile)\n  -- code\n  profile:stop()\nend"
            },
            {
                "name": "profileFunc",
                "arguments": "[args], [profile]",
                "description": "Profile a function, this is similar to AppleCake.profile but generates the profile name for you.",
                "example": "local profile\nfunction love.update(dt)\n  profile = AppleCake.profileFunc({deltaTime=dt}, profile)\n  -- code\n  profile:stop()\nend"
            },
            {
                "name": "profile:stop",
                "description": "Stop the mentioned profile.",
                "example": "profile:stop()"
            },
            {
                "name": "stopProfile",
                "arguments": "profile",
                "description": "Stop the mentioned profile. It's usually quicker to call profile:stop(), which calls the same function",
                "example": "AppleCake.stopProfile(profile)"
            },
            {
                "name": "mark",
                "arguments": "name, [scope = \"p\"], [args]",
                "description": "Mark a timeless event. Scope changes the notice-able size of the mark on the viewer. \"p\" for process, \"t\" for thread.",
                "example": "AppleCake.mark(\"keyPressed\", \"p\", {key=key})"
            },
            {
                "name": "counter",
                "arguments": "name, [args], [counter]",
                "description": "Track a variables change overtime with a bar graph.",
                "example": "local counter\nfunction love.update(dt)\n  counter = AppleCake.counter(\"Memory\", {memory=collectgarbage(\"count\")}, counter)\nend"
            },
            {
                "name": "countMemory",
                "arguments": "[memoryScale = \"kilobyte\"]",
                "description": "Record the current memory usage. By default this is in \"kilobyte\"; other options include \"megabyte\" and \"byte\"",
                "example": "AppleCake.countMemory()\nAppleCake.countMemory(\"byte\")\nAppleCake.countMemory(\"megabyte\")"
            },
            {
                "name": "setName",
                "arguments": "name",
                "description": "Set the name for the process and the current thread",
                "example": "AppleCake.setName(\"EpicGame4004\")"
            },
            {
                "name": "setThreadName",
                "arguments": "name",
                "description": "Set the name for the current thread",
                "example": "Applecake.setThreadName(\"Server network\")"
            },
            {
                "name": "AppleCake.jprof.push",
                "arguments": "name, [annotation]",
                "description": "Push a profile to the current stack.",
                "example": "AppleCake.jprof.push(\"frame\")"
            },
            {
                "name": "AppleCake.jprof.pop",
                "arguments": "[name]",
                "description": "Pop the current profile from the stack. Use the name argument to ensure it is the correct profile",
                "example": "AppleCake.jprof.pop()\nAppleCake.jprof.pop(\"frame\")"
            },
            {
                "name": "AppleCake.jprof.popAll",
                "description": "Pop all on the current stack.",
                "example": "AppleCake.jprof.popAll()"
            },
            {
                "name": "AppleCake.jprof.write",
                "arguments": "[filename]",
                "description": "Different to jprof due to AppleCake's workflow. Will close the current file and open a new file with the give filename. Defaults to \"profile.json\"",
                "example": "AppleCake.jprof.write()\nAppleCake.write(\"profile-server.json\")"
            },
            {
                "name": "AppleCake.jprof.enabled",
                "arguments": "enabled",
                "description": "Enable or disable profiles after this point.",
                "example": "AppleCake.jprof.enabled(true)\nAppleCake.jprof.enabled(false)"
            },
            {
                "name": "AppleCake.jprof.connect",
                "description": "This function isn't supported in AppleCake",
                "example": "AppleCake.jprof.connect() -- will error"
            },
            {
                "name": "AppleCake.jprof.netFlush",
                "description": "This function isn't supported in AppleCake",
                "example": "AppleCake.jprof.netFlush() -- will error"
            },
            {
                "name": "AppleCake.jprof.START",
                "arguments": "[filename = \"profile\"], [name = love.filesystem.getIdentity()]",
                "description": "Same function as AppleCake.beginSession, but added to the jprof table.",
                "example": "AppleCake.jprof.START()\nAppleCake.jprof.START(\"profile-server.json\", \"EpicGame4004\")"
            },
            {
                "name": "AppleCake.jprof.COUNTMEMORY",
                "arguments": "[memoryScale]",
                "description": "Same funtion as AppleCake.countMemory, but added to the jprof table.",
                "example": "AppleCake.jprof.COUNTMEMORY()\nAppleCake.jprof.COUNTMEMORY(\"megabyte\")"
            },
            {
                "name": "setBuffer",
                "argument": "[enable = false]",
                "description": "Enables buffering of data on the current thread before it is sent to the saving thread. Can increase performance greatly at a small cost to memory. A flush will occur when called.",
                "example": "AppleCake.enable(true)\nAppleCake.enable(false)"
            },
            {
                "name": "flush",
                "description": "Flush all data currently held by the buffer.",
                "example": "AppleCake.flush()"
            }
        ]
    },
    {
        "name": "json.lua",
        "author": "rxi",
        "url": "https://github.com/rxi/json.lua",
        "description": "A lightweight JSON library for Lua"
    },
    {
        "name": "Mathsies",
        "author": "Tachytaenius",
        "url": "https://github.com/wolfboyft/mathsies",
        "description": "LuaJIT maths library with support for floating point determinism"
    }
]