FlashImgs ZeroGPU Space: Gradio SDK, AGPL-3.0 wrapper, vendored sm_120 wheels

.gitignore

@@ -0,0 +1,23 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+
+# Caches / tooling
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.venv/
+venv/
+
+# App outputs (default output dir lives under /tmp, but ignore local overrides)
+outputs/
+
+# OS / editor
+.DS_Store
+*.swp
+.idea/
+.vscode/

LICENSE

@@ -0,0 +1,661 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

NOTICE

@@ -0,0 +1,27 @@
+FlashImgs Hugging Face Space
+Copyright (C) 2025 OpsiClear
+
+The wrapper code in this repository (app.py and configuration files) is licensed
+under the GNU Affero General Public License v3.0 (AGPL-3.0). See the LICENSE file
+for the full terms.
+
+----------------------------------------------------------------------
+Vendored components (NOT covered by the AGPL-3.0 license above)
+----------------------------------------------------------------------
+
+This Space vendors prebuilt wheels of the FlashImgs library under wheels/:
+
+    flashimgs            (built from https://github.com/OpsiClear/flashimgs,
+                          commit 11d4d3b)
+    simple_sum_backend   (CUDA rasterizer backend)
+    fussim               (fused-SSIM CUDA extension, OpsiClear fork)
+
+The CUDA-extension wheels (fussim, simple_sum_backend) are compiled for CPython
+3.12, torch 2.11.0+cu128 (CUDA 12.8), and NVIDIA Blackwell sm_120.
+
+FlashImgs and simple_sum_backend are distributed under the OpsiClear Restrictive
+License — non-commercial use only, no derivatives, and no redistribution. The
+fussim extension derives from github.com/rahul-goel/fused-ssim (MIT license,
+Rahul Goel et al.). The AGPL-3.0 license of this wrapper does NOT extend to these
+vendored components; building, deploying, and using the application is subject to
+the FlashImgs license terms, which take precedence for them.

README.md

@@ -1,13 +1,101 @@
 ---
-title: Flashimgs
-emoji: 😻
-colorFrom: gray
-colorTo: blue
+title: FlashImgs
+emoji: 💠
+colorFrom: indigo
+colorTo: purple
 sdk: gradio
-sdk_version: 6.18.0
-python_version: '3.13'
+sdk_version: 6.16.0
+python_version: "3.12.12"
 app_file: app.py
+suggested_hardware: zero-a10g
+fullWidth: true
 pinned: false
+license: agpl-3.0
+short_description: Adaptive 2D Gaussian splat fitting for images (ZeroGPU).
+tags:
+  - gaussian-splatting
+  - 2d-gaussian-splatting
+  - image-representation
+  - gradio
+  - zerogpu
+  - computer-vision
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# FlashImgs — 2D Gaussian Splatting for Images
+
+Fit any image as a set of **2D Gaussians** in seconds, preview the
+reconstruction and a 3D Gaussian-splat point cloud, and export files for
+standard splat viewers. This Space is a [Gradio](https://www.gradio.app/)
+wrapper around the [FlashImgs](https://github.com/OpsiClear/flashimgs) adaptive
+fitter, running on **[ZeroGPU](https://huggingface.co/docs/hub/spaces-zerogpu)**.
+It does **not** use the gaussifier feedforward sampler, AOTI, or TensorRT path.
+
+## Hardware (ZeroGPU)
+
+The GPU-bound fit is wrapped with `@spaces.GPU`, so the Space requests a
+ZeroGPU (NVIDIA RTX Pro 6000 Blackwell, `sm_120`) slice only while a fit runs
+and releases it immediately after.
+
+To host this on ZeroGPU you need **ZeroGPU enabled on the account** that owns the
+Space (a **PRO** subscription for a personal account, or a Team/Enterprise plan
+for an organization), then select **ZeroGPU** in *Settings → Hardware*. The
+`@spaces.GPU` decorator is a no-op off ZeroGPU, so the Space also runs unchanged
+on a standard GPU tier.
+
+## How to use
+
+1. Upload an image (PNG/WebP alpha is honored automatically as a fit mask).
+2. Adjust the **Fit** settings (max side, gaussian budget, steps, loss) if needed.
+3. Click **Fit**.
+4. Inspect the **3DGS** point-cloud preview and the **Image** reconstruction.
+5. Tweak the **PLY** export controls (opacity, scale, thickness, Y axis) — the
+   3D preview updates live — then download the files.
+
+### Masks
+
+- Embedded PNG/WebP alpha masks are used automatically to fit only the subject.
+- With **Treat image border as mask border** enabled, opaque/RGB images use the
+  image frame as the mask boundary.
+
+## Outputs
+
+- Reconstruction preview plus PSNR / SSIM and timing metrics.
+- `.splat2d` file compatible with the FlashImgs web viewer.
+- Edited planar **3DGS `.ply`** for standard splat viewers. The `factor_rgb`
+  opacity scale, mask-edge scale clamp, thickness, and Y-axis controls update
+  the preview while you adjust them; the downloadable PLY is always the latest
+  edited file.
+
+## How the build works
+
+ZeroGPU Spaces use the Gradio SDK and install from `requirements.txt` with no
+build-time CUDA toolchain, so FlashImgs and its CUDA backends cannot be compiled
+on the Space. Instead, prebuilt wheels are vendored under [`wheels/`](wheels):
+
+- `flashimgs` (pure Python, built from commit `11d4d3b`)
+- `fussim` and `simple_sum_backend` — CUDA extensions compiled for
+  **CPython 3.12**, **torch 2.11.0+cu128 (CUDA 12.8)**, and **Blackwell `sm_120`**
+
+These match `torch==2.11.0+cu128` / `torchvision==0.26.0+cu128` pinned in
+`requirements.txt`, and `python_version: 3.12.12` in the front matter above.
+`cfgs/default.yaml` is included at the Space root because FlashImgs resolves its
+default config relative to the working directory.
+
+To rebuild the wheels for a new FlashImgs revision (or a different torch / CUDA
+arch), build `fussim` and `simple_sum_backend` from the FlashImgs source with
+`TORCH_CUDA_ARCH_LIST=12.0+PTX` against the target torch, and rebuild the
+`flashimgs` wheel with full package discovery.
+
+## License
+
+The wrapper code in this repository (`app.py`, configuration) is released under
+the **GNU Affero General Public License v3.0** (AGPL-3.0) — see [`LICENSE`](LICENSE)
+and [`NOTICE`](NOTICE). Because AGPL-3.0 is a network-copyleft license, anyone who
+runs a modified version of this wrapper as a network service must offer its users
+the modified source.
+
+The vendored **FlashImgs** wheels (`flashimgs`, `simple_sum_backend`, and the
+OpsiClear `fussim` fork) are a separate work under the **OpsiClear Restrictive
+License** (non-commercial use only). The AGPL-3.0 license of this wrapper does
+not extend to the FlashImgs engine; running the deployed app is subject to the
+FlashImgs terms.

app.py

@@ -0,0 +1,701 @@
+# FlashImgs Hugging Face Space
+# Copyright (C) 2025 OpsiClear
+#
+# This program (the Gradio wrapper) is free software: you can redistribute it
+# and/or modify it under the terms of the GNU Affero General Public License v3.0
+# as published by the Free Software Foundation. See the LICENSE file for the full
+# text. It is distributed WITHOUT ANY WARRANTY.
+#
+# The bundled FlashImgs engine wheels (wheels/) are a separate work under the
+# OpsiClear Restrictive License and are NOT covered by the AGPL; see NOTICE.
+from __future__ import annotations
+
+import gc
+import math
+import os
+import shutil
+import struct
+import time
+import uuid
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+import torch
+from PIL import Image, ImageOps
+
+try:
+    import spaces  # Hugging Face ZeroGPU runtime
+except Exception:  # effect-free fallback when not running on ZeroGPU
+    class _SpacesStub:
+        @staticmethod
+        def GPU(*args, **kwargs):
+            def _decorator(func):
+                return func
+
+            if args and callable(args[0]):
+                return args[0]
+            return _decorator
+
+    spaces = _SpacesStub()
+
+
+os.environ.setdefault("FLASHIMGS_GAUSSIFIER_AOTI", "0")
+
+OUTPUT_ROOT = Path(os.environ.get("FLASHIMGS_OUTPUT_DIR", "/tmp/flashimgs_hf_outputs"))
+OUTPUT_ROOT.mkdir(parents=True, exist_ok=True)
+
+APP_CSS = """
+#workspace {
+    max-width: 1440px;
+    margin: 0 auto;
+    gap: 16px;
+    align-items: flex-start;
+}
+.settings-panel {
+    flex: 0 0 330px !important;
+    max-width: 350px !important;
+    min-width: 300px !important;
+}
+.results-panel {
+    flex: 1 1 0 !important;
+    min-width: min(760px, 100%) !important;
+}
+.preview-tabs, .preview-tabs > div {
+    min-width: 0;
+}
+.download-row {
+    gap: 12px;
+}
+@media (max-width: 920px) {
+    #workspace {
+        display: block;
+    }
+    .settings-panel, .results-panel {
+        max-width: none !important;
+        min-width: 0 !important;
+        flex-basis: auto !important;
+    }
+}
+"""
+
+
+def _load_flashimgs():
+    import flashimgs
+
+    return flashimgs
+
+
+def _device_name() -> str:
+    if not torch.cuda.is_available():
+        return "CPU"
+    return torch.cuda.get_device_name(torch.cuda.current_device())
+
+
+def _prepare_image(image: Image.Image, max_side: int) -> tuple[torch.Tensor, Image.Image, torch.Tensor | None, str]:
+    if image is None:
+        raise gr.Error("Upload an image first.")
+
+    image = ImageOps.exif_transpose(image)
+    original_w, original_h = image.size
+    has_alpha = image.mode in {"RGBA", "LA"} or (image.mode == "P" and "transparency" in image.info)
+    image_rgba = image.convert("RGBA")
+
+    max_side = int(max_side)
+    if max_side > 0 and max(original_w, original_h) > max_side:
+        scale = max_side / float(max(original_w, original_h))
+        new_size = (max(1, round(original_w * scale)), max(1, round(original_h * scale)))
+        image_rgba = image_rgba.resize(new_size, Image.Resampling.LANCZOS)
+
+    rgba = np.asarray(image_rgba, dtype=np.uint8)
+    rgb = rgba[..., :3].astype(np.float32) / 255.0
+    image_rgb = Image.fromarray(rgba[..., :3], mode="RGB")
+    image_tensor = torch.from_numpy(rgb).permute(2, 0, 1).contiguous()
+
+    mask_tensor = None
+    if has_alpha:
+        alpha = rgba[..., 3]
+        if alpha.min() < 255:
+            mask_array = (alpha > 127).astype(np.float32)
+            if np.any(mask_array):
+                mask_tensor = torch.from_numpy(mask_array).unsqueeze(0).contiguous()
+
+    size_note = f"{original_w}x{original_h}"
+    if image_rgba.size != (original_w, original_h):
+        size_note += f" -> {image_rgba.size[0]}x{image_rgba.size[1]}"
+    return image_tensor, image_rgb, mask_tensor, size_note
+
+
+def _tensor_to_pil(tensor: torch.Tensor) -> Image.Image:
+    array = (
+        tensor.detach()
+        .clamp(0.0, 1.0)
+        .mul(255.0)
+        .byte()
+        .permute(1, 2, 0)
+        .cpu()
+        .numpy()
+    )
+    return Image.fromarray(array, mode="RGB")
+
+
+def _prune_old_outputs(keep: int = 20) -> None:
+    runs = [p for p in OUTPUT_ROOT.iterdir() if p.is_dir()]
+    runs.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+    for path in runs[keep:]:
+        shutil.rmtree(path, ignore_errors=True)
+
+
+def _load_splat2d(path: Path):
+    with path.open("rb") as f:
+        magic = f.read(4)
+        if magic != b"GS2D":
+            raise gr.Error("The cached Splat2D file is not a FlashImgs GS2D file.")
+        header = f.read(8)
+        if len(header) != 8:
+            raise gr.Error("The cached Splat2D file is truncated.")
+        n_gaussians, height, width = struct.unpack("<IHH", header)
+        floats = np.fromfile(f, dtype="<f4")
+
+    if n_gaussians <= 0:
+        raise gr.Error("The cached Splat2D file has no Gaussians.")
+    if floats.size % n_gaussians != 0:
+        raise gr.Error("The cached Splat2D file has an invalid payload length.")
+
+    floats_per_gaussian = floats.size // n_gaussians
+    feature_dim = floats_per_gaussian - 5
+    if feature_dim <= 0:
+        raise gr.Error("The cached Splat2D file does not contain color features.")
+
+    offset = 0
+    xy = floats[offset : offset + n_gaussians * 2].reshape(n_gaussians, 2)
+    offset += n_gaussians * 2
+    raw_scale = floats[offset : offset + n_gaussians * 2].reshape(n_gaussians, 2)
+    offset += n_gaussians * 2
+    rot = floats[offset : offset + n_gaussians]
+    offset += n_gaussians
+    feat = floats[offset:].reshape(n_gaussians, feature_dim)
+
+    # The Gradio training path uses FlashImgs' normal inverse-scale parameterization.
+    scale_px = 1.0 / np.maximum(raw_scale, 0.01)
+    return xy, scale_px.astype(np.float32), rot, feat, int(height), int(width)
+
+
+def _mask_edge_distance(mask_array: np.ndarray) -> np.ndarray:
+    import cv2
+
+    mask_u8 = (mask_array > 0).astype(np.uint8)
+    padded = np.pad(mask_u8, 1, mode="constant", constant_values=0)
+    dist = cv2.distanceTransform(padded, cv2.DIST_L2, cv2.DIST_MASK_PRECISE)
+    return dist[1:-1, 1:-1].astype(np.float32, copy=False)
+
+
+def _write_ply_from_splat_arrays(
+    path: Path,
+    xy: np.ndarray,
+    scale_px: np.ndarray,
+    rot: np.ndarray,
+    feat: np.ndarray,
+    height: int,
+    width: int,
+    *,
+    mask_array: np.ndarray | None = None,
+    mask_edge_clamp: float = 0.35,
+    opacity_scale: float,
+    min_opacity: float,
+    max_opacity: float,
+    scale_multiplier: float,
+    thickness: float,
+    y_axis: str,
+) -> None:
+    n_gaussians = int(xy.shape[0])
+    height_f = max(float(height), 1.0)
+    width_f = max(float(width), 1.0)
+    aspect = width_f / height_f
+    world_height = 1.0
+    thickness = max(float(thickness), 1e-8)
+    opacity_mode = "factor_rgb"
+    opacity_scale = max(float(opacity_scale), 1e-6)
+    min_opacity = min(1.0 - 1e-6, max(1e-6, float(min_opacity)))
+    max_opacity = min(1.0 - 1e-6, max(min_opacity, float(max_opacity)))
+    scale_multiplier = max(float(scale_multiplier), 1e-6)
+    y_axis = str(y_axis).lower().strip()
+    if y_axis not in {"down", "up"}:
+        y_axis = "down"
+
+    if mask_array is not None and float(mask_edge_clamp) > 0:
+        dist = _mask_edge_distance(mask_array)
+        x_px = np.clip(np.floor(xy[:, 0] * float(width)).astype(np.int64), 0, int(width) - 1)
+        y_px = np.clip(np.floor(xy[:, 1] * float(height)).astype(np.int64), 0, int(height) - 1)
+        max_scale = np.maximum(0.25, dist[y_px, x_px] * float(mask_edge_clamp)).astype(np.float32)
+        scale_px = np.minimum(scale_px, max_scale[:, None]).astype(np.float32, copy=False)
+
+    if feat.shape[1] == 1:
+        rgb = np.repeat(feat[:, :1], 3, axis=1)
+    elif feat.shape[1] < 3:
+        rgb = np.pad(feat, ((0, 0), (0, 3 - feat.shape[1])), mode="constant")
+    else:
+        rgb = feat[:, :3]
+    rgb = np.clip(rgb, 0.0, 1.0).astype(np.float32, copy=False)
+
+    amp = np.max(rgb, axis=1).astype(np.float32, copy=False)
+    alpha = np.clip(opacity_scale * amp, min_opacity, max_opacity).astype(np.float32)
+    ply_rgb = np.clip(rgb / alpha[:, None], 0.0, 1.0).astype(np.float32, copy=False)
+
+    alpha = np.clip(alpha, 1e-6, 1.0 - 1e-6).astype(np.float32, copy=False)
+    opacity_logit = np.log(alpha / (1.0 - alpha)).astype(np.float32, copy=False)
+    f_dc = (ply_rgb - 0.5) / 0.28209479177387814
+
+    names = ["x", "y", "z", "nx", "ny", "nz", "f_dc_0", "f_dc_1", "f_dc_2"]
+    names += [f"f_rest_{i}" for i in range(45)]
+    names += ["opacity", "scale_0", "scale_1", "scale_2", "rot_0", "rot_1", "rot_2", "rot_3"]
+    names += ["fi_u", "fi_v", "fi_scale_x_px", "fi_scale_y_px", "fi_rot", "fi_r", "fi_g", "fi_b"]
+
+    vertices = np.zeros(n_gaussians, dtype=np.dtype([(name, "<f4") for name in names]))
+    vertices["x"] = (xy[:, 0] - 0.5) * aspect * world_height
+    if y_axis == "down":
+        vertices["y"] = (xy[:, 1] - 0.5) * world_height
+        theta = -rot
+    else:
+        vertices["y"] = (0.5 - xy[:, 1]) * world_height
+        theta = rot
+    vertices["z"] = 0.0
+    vertices["f_dc_0"] = f_dc[:, 0]
+    vertices["f_dc_1"] = f_dc[:, 1]
+    vertices["f_dc_2"] = f_dc[:, 2]
+    vertices["opacity"] = opacity_logit
+
+    scale_world = np.maximum(scale_px * scale_multiplier * (world_height / height_f), 1e-8)
+    vertices["scale_0"] = np.log(scale_world[:, 0])
+    vertices["scale_1"] = np.log(scale_world[:, 1])
+    vertices["scale_2"] = math.log(thickness)
+    vertices["rot_0"] = np.cos(0.5 * theta)
+    vertices["rot_1"] = 0.0
+    vertices["rot_2"] = 0.0
+    vertices["rot_3"] = np.sin(0.5 * theta)
+    vertices["fi_u"] = xy[:, 0]
+    vertices["fi_v"] = xy[:, 1]
+    vertices["fi_scale_x_px"] = scale_px[:, 0]
+    vertices["fi_scale_y_px"] = scale_px[:, 1]
+    vertices["fi_rot"] = rot
+    vertices["fi_r"] = rgb[:, 0]
+    vertices["fi_g"] = rgb[:, 1]
+    vertices["fi_b"] = rgb[:, 2]
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    header = [
+        "ply",
+        "format binary_little_endian 1.0",
+        "comment FlashImgs planar 2DGS export for standard 3DGS viewers",
+        f"comment fi_image_width {int(width)}",
+        f"comment fi_image_height {int(height)}",
+        f"comment fi_world_height {world_height:.9g}",
+        f"comment fi_world_width {aspect * world_height:.9g}",
+        f"comment fi_y_axis {y_axis}",
+        f"comment fi_opacity_mode {opacity_mode}",
+        f"comment fi_opacity_scale {opacity_scale:.9g}",
+        f"comment fi_min_opacity {min_opacity:.9g}",
+        f"comment fi_max_opacity {max_opacity:.9g}",
+        f"comment fi_scale_multiplier {scale_multiplier:.9g}",
+        f"comment fi_mask_edge_clamp {float(mask_edge_clamp):.9g}",
+        f"element vertex {n_gaussians}",
+    ]
+    header.extend(f"property float {name}" for name in names)
+    header.append("end_header")
+    with path.open("wb") as f:
+        f.write(("\n".join(header) + "\n").encode("ascii"))
+        vertices.tofile(f)
+
+
+def update_ply_preview(
+    splat_path_value,
+    current_ply_path_value,
+    mask_path_value,
+    mask_edge_clamp: float,
+    ply_opacity_scale: float,
+    ply_min_opacity: float,
+    ply_max_opacity: float,
+    ply_scale_multiplier: float,
+    ply_thickness: float,
+    ply_y_axis: str,
+):
+    if not splat_path_value:
+        return gr.update(), gr.update(), current_ply_path_value
+    splat_path = Path(str(splat_path_value))
+    if not splat_path.exists():
+        return gr.update(), gr.update(), current_ply_path_value
+
+    xy, scale_px, rot, feat, height, width = _load_splat2d(splat_path)
+    mask_array = None
+    if mask_path_value:
+        mask_path = Path(str(mask_path_value))
+        if mask_path.exists():
+            mask_array = np.load(mask_path).astype(bool)
+    old_path = Path(str(current_ply_path_value)) if current_ply_path_value else None
+    ply_path = splat_path.parent / f"flashimgs_fit_edited_{uuid.uuid4().hex[:8]}.ply"
+    _write_ply_from_splat_arrays(
+        ply_path,
+        xy,
+        scale_px,
+        rot,
+        feat,
+        height,
+        width,
+        mask_array=mask_array,
+        mask_edge_clamp=float(mask_edge_clamp),
+        opacity_scale=float(ply_opacity_scale),
+        min_opacity=float(ply_min_opacity),
+        max_opacity=float(ply_max_opacity),
+        scale_multiplier=float(ply_scale_multiplier),
+        thickness=float(ply_thickness),
+        y_axis=ply_y_axis,
+    )
+    if old_path and old_path.name.startswith("flashimgs_fit_edited_") and old_path.exists():
+        old_path.unlink(missing_ok=True)
+    return str(ply_path), str(ply_path), str(ply_path)
+
+
+def _fit_with_progress(
+    flashimgs,
+    image_tensor: torch.Tensor,
+    *,
+    gaussians: int,
+    steps: int,
+    lr: float,
+    scale: float,
+    loss: str,
+    seed: int,
+    mask_tensor: torch.Tensor | None,
+    mask_border_padding: bool,
+    progress: gr.Progress,
+):
+    import main as _main
+
+    total_steps = max(1, int(steps))
+    session = flashimgs.Session.from_tensor(
+        image_tensor,
+        gaussians=max(0, int(gaussians)),
+        scale=float(scale),
+        loss=loss,
+        lr_mult=float(lr),
+        device="cuda",
+        seed=int(seed),
+        mask_tensor=mask_tensor,
+        mask_border_padding=bool(mask_border_padding),
+    )
+
+    last_update = 0
+    update_every = max(1, total_steps // 100)
+
+    def on_step(completed_step: int, _gs) -> None:
+        nonlocal last_update
+        if completed_step < total_steps and completed_step - last_update < update_every:
+            return
+        last_update = int(completed_step)
+        frac = min(1.0, max(0.0, completed_step / total_steps))
+        progress(
+            0.10 + 0.78 * frac,
+            desc=f"Fitting splats: {completed_step:,}/{total_steps:,} steps",
+        )
+
+    elapsed_s, _, _ = _main.train_loop(
+        session.model,
+        total_steps,
+        verbose=False,
+        snapshot_hook=on_step,
+    )
+    on_step(total_steps, session.model)
+
+    return session, 0.0, 0.0, float(elapsed_s)
+
+
+def _fit_duration(*args, **kwargs) -> float:
+    """Seconds of ZeroGPU time to reserve for a fit, estimated from its arguments.
+
+    Mirrors ``fit_image``'s positional signature ``(image, max_side, gaussians,
+    steps, ...)``. Fits are fast, but reserve headroom for large images, high
+    step counts, and first-call CUDA + extension warmup.
+    """
+
+    def _arg(idx: int, default: float) -> float:
+        try:
+            return float(args[idx])
+        except (IndexError, TypeError, ValueError):
+            return default
+
+    max_side = _arg(1, 1536.0)
+    gaussians = _arg(2, 0.0)
+    steps = _arg(3, 900.0)
+    est = 30.0 + 0.06 * steps + (gaussians / 100000.0) * 40.0
+    if max_side == 0.0 or max_side > 2048.0:
+        est += 30.0
+    return float(min(180.0, max(45.0, est)))
+
+
+@spaces.GPU(duration=_fit_duration)
+def fit_image(
+    image: Image.Image,
+    max_side: int,
+    gaussians: int,
+    steps: int,
+    lr: float,
+    scale: float,
+    loss: str,
+    render_height: int,
+    seed: int,
+    mask_border_padding: bool,
+    mask_edge_clamp: float,
+    ply_opacity_scale: float,
+    ply_min_opacity: float,
+    ply_max_opacity: float,
+    ply_scale_multiplier: float,
+    ply_thickness: float,
+    ply_y_axis: str,
+    progress: gr.Progress = gr.Progress(track_tqdm=False),
+):
+    if not torch.cuda.is_available():
+        raise gr.Error(
+            "FlashImgs fitting needs CUDA. In Space settings, select a GPU hardware tier."
+        )
+
+    progress(0.02, desc="Preparing image")
+    image_tensor, resized_image, mask_tensor, size_note = _prepare_image(image, max_side)
+    fit_w, fit_h = resized_image.size
+    mask_source = "alpha" if mask_tensor is not None else "none"
+    if mask_tensor is None and bool(mask_border_padding):
+        mask_tensor = torch.ones((1, fit_h, fit_w), dtype=torch.float32).contiguous()
+        mask_source = "image border"
+
+    run_dir = OUTPUT_ROOT / uuid.uuid4().hex
+    run_dir.mkdir(parents=True, exist_ok=True)
+    splat_path = run_dir / "flashimgs_fit.splat2d"
+    ply_path = run_dir / "flashimgs_fit.ply"
+    mask_path = run_dir / "mask.npy"
+
+    flashimgs = _load_flashimgs()
+    session = None
+    psnr = 0.0
+    ssim = 0.0
+    train_elapsed_s = 0.0
+    start = time.time()
+
+    try:
+        progress(0.1, desc=f"Fitting splats: 0/{max(1, int(steps)):,} steps")
+        session, psnr, ssim, train_elapsed_s = _fit_with_progress(
+            flashimgs,
+            image_tensor,
+            gaussians=gaussians,
+            steps=steps,
+            lr=lr,
+            scale=scale,
+            loss=loss,
+            seed=seed,
+            mask_tensor=mask_tensor,
+            mask_border_padding=mask_border_padding,
+            progress=progress,
+        )
+
+        if mask_tensor is not None:
+            progress(0.86, desc="Pruning mask boundary")
+            session.mask_prune()
+
+        session.materialize_gate()
+        psnr, ssim = session.evaluate()
+
+        progress(0.88, desc="Rendering")
+        render_at = None if int(render_height) <= 0 else int(render_height)
+        reconstruction = _tensor_to_pil(session.render(height=render_at))
+
+        progress(0.94, desc="Exporting")
+        session.export_splat2d(str(splat_path))
+        mask_state_path = None
+        mask_array = None
+        if mask_tensor is not None:
+            mask_array = mask_tensor.squeeze(0).cpu().numpy().astype(bool)
+            np.save(mask_path, mask_array.astype(np.uint8))
+            mask_state_path = str(mask_path)
+
+        xy, scale_px, rot, feat, height, width = _load_splat2d(splat_path)
+        _write_ply_from_splat_arrays(
+            ply_path,
+            xy,
+            scale_px,
+            rot,
+            feat,
+            height,
+            width,
+            mask_array=mask_array,
+            mask_edge_clamp=float(mask_edge_clamp),
+            opacity_scale=float(ply_opacity_scale),
+            min_opacity=float(ply_min_opacity),
+            max_opacity=float(ply_max_opacity),
+            scale_multiplier=float(ply_scale_multiplier),
+            thickness=float(ply_thickness),
+            y_axis=ply_y_axis,
+        )
+
+        total_s = time.time() - start
+        n_gaussians = int(session.n_gaussians)
+        metrics = "\n".join(
+            [
+                f"Device: {_device_name()}",
+                f"Input: {size_note}",
+                f"Fit resolution: {fit_w}x{fit_h}",
+                f"Mask: {mask_source}",
+                f"Mask border padding: {'on' if mask_tensor is not None and mask_border_padding else 'off'}",
+                f"Mask edge clamp: {float(mask_edge_clamp):.2f}x" if mask_tensor is not None else "Mask edge clamp: off",
+                f"Gaussians: {n_gaussians:,}",
+                f"Steps: {int(steps):,}",
+                f"PSNR: {psnr:.2f} dB",
+                f"SSIM: {ssim:.5f}",
+                f"Training time: {train_elapsed_s:.2f} s",
+                f"Total request time: {total_s:.2f} s",
+            ]
+        )
+        _prune_old_outputs()
+        progress(1.0, desc="Done")
+        return reconstruction, metrics, str(splat_path), str(ply_path), str(ply_path), str(splat_path), str(ply_path), mask_state_path
+    finally:
+        del session
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+
+with gr.Blocks(title="FlashImgs") as demo:
+    gr.Markdown("# FlashImgs")
+    splat_state = gr.State(value=None)
+    ply_state = gr.State(value=None)
+    mask_state = gr.State(value=None)
+    with gr.Row(elem_id="workspace"):
+        with gr.Column(scale=1, min_width=300, elem_classes=["settings-panel"]):
+            image = gr.Image(
+                label="Image",
+                type="pil",
+                sources=["upload", "clipboard"],
+                image_mode="RGBA",
+                height=240,
+            )
+            run = gr.Button("Fit", variant="primary")
+            with gr.Accordion("Fit", open=True):
+                max_side = gr.Slider(0, 4096, value=1536, step=64, label="Max side (0 = original)")
+                gaussians = gr.Slider(0, 100000, value=0, step=1000, label="Gaussians")
+                steps = gr.Slider(100, 3200, value=900, step=100, label="Steps")
+                loss = gr.Dropdown(["l2", "l1", "l2+ssim", "l1+ssim"], value="l2", label="Loss")
+                mask_border_padding = gr.Checkbox(value=True, label="Treat image border as mask border")
+                mask_edge_clamp = gr.Slider(0.0, 1.0, value=0.35, step=0.05, label="Mask edge scale clamp")
+            with gr.Accordion("PLY", open=True):
+                ply_opacity_scale = gr.Slider(0.1, 4.0, value=1.0, step=0.1, label="Opacity scale")
+                ply_min_opacity = gr.Slider(0.001, 0.25, value=0.01, step=0.001, label="Min opacity")
+                ply_max_opacity = gr.Slider(0.05, 0.99, value=0.95, step=0.01, label="Max opacity")
+                ply_scale_multiplier = gr.Slider(0.25, 3.0, value=1.0, step=0.05, label="XY scale multiplier")
+                ply_thickness = gr.Slider(0.00001, 0.002, value=0.0001, step=0.00001, label="Z thickness")
+                ply_y_axis = gr.Dropdown(["down", "up"], value="down", label="PLY Y axis")
+                update_ply = gr.Button("Update PLY Preview")
+            with gr.Accordion("Advanced", open=False):
+                lr = gr.Slider(1.0, 16.0, value=11.0, step=0.5, label="LR")
+                scale = gr.Slider(0.5, 4.0, value=1.5, step=0.1, label="Scale")
+                render_height = gr.Slider(0, 2048, value=0, step=128, label="Render height")
+                seed = gr.Number(value=42, precision=0, label="Seed")
+
+        with gr.Column(scale=3, min_width=520, elem_classes=["results-panel"]):
+            with gr.Tabs(elem_classes=["preview-tabs"]):
+                with gr.Tab("3DGS"):
+                    ply_preview = gr.Model3D(
+                        label="3DGS Preview",
+                        display_mode="point_cloud",
+                        clear_color=(0.03, 0.03, 0.03, 1.0),
+                        height=620,
+                    )
+                with gr.Tab("Image"):
+                    reconstruction = gr.Image(label="Reconstruction", type="pil", height=620)
+            with gr.Accordion("Details and downloads", open=False):
+                metrics = gr.Textbox(label="Metrics", lines=9)
+                with gr.Row(elem_classes=["download-row"]):
+                    splat = gr.File(label="Splat2D")
+                    ply = gr.File(label="Edited 3DGS PLY")
+
+    gr.Markdown(
+        "FlashImgs Space · © 2025 OpsiClear · wrapper licensed "
+        "[AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.html) — source available "
+        "in this Space's **Files** tab. The bundled FlashImgs engine is separately "
+        "licensed (non-commercial); see NOTICE. No warranty.",
+        elem_id="app-footer",
+    )
+
+    run.click(
+        fn=fit_image,
+        inputs=[
+            image,
+            max_side,
+            gaussians,
+            steps,
+            lr,
+            scale,
+            loss,
+            render_height,
+            seed,
+            mask_border_padding,
+            mask_edge_clamp,
+            ply_opacity_scale,
+            ply_min_opacity,
+            ply_max_opacity,
+            ply_scale_multiplier,
+            ply_thickness,
+            ply_y_axis,
+        ],
+        outputs=[reconstruction, metrics, splat, ply, ply_preview, splat_state, ply_state, mask_state],
+        show_progress_on=[ply_preview],
+    )
+
+    ply_update_inputs = [
+        splat_state,
+        ply_state,
+        mask_state,
+        mask_edge_clamp,
+        ply_opacity_scale,
+        ply_min_opacity,
+        ply_max_opacity,
+        ply_scale_multiplier,
+        ply_thickness,
+        ply_y_axis,
+    ]
+    ply_update_outputs = [ply, ply_preview, ply_state]
+
+    update_ply.click(
+        fn=update_ply_preview,
+        inputs=ply_update_inputs,
+        outputs=ply_update_outputs,
+        show_progress="minimal",
+        show_progress_on=[ply_preview],
+        trigger_mode="always_last",
+        concurrency_limit=1,
+        concurrency_id="ply_update",
+    )
+    for control in [mask_edge_clamp, ply_opacity_scale, ply_min_opacity, ply_max_opacity, ply_scale_multiplier, ply_thickness]:
+        control.input(
+            fn=update_ply_preview,
+            inputs=ply_update_inputs,
+            outputs=ply_update_outputs,
+            show_progress="hidden",
+            trigger_mode="always_last",
+            concurrency_limit=1,
+            concurrency_id="ply_update",
+        )
+    for control in [ply_y_axis]:
+        control.change(
+            fn=update_ply_preview,
+            inputs=ply_update_inputs,
+            outputs=ply_update_outputs,
+            show_progress="hidden",
+            trigger_mode="always_last",
+            concurrency_limit=1,
+            concurrency_id="ply_update",
+        )
+
+if __name__ == "__main__":
+    demo.queue(default_concurrency_limit=1, max_size=8).launch(
+        server_name="0.0.0.0",
+        server_port=int(os.environ.get("PORT", "7860")),
+        css=APP_CSS,
+    )

cfgs/default.yaml

@@ -0,0 +1,68 @@
+seed:                  123
+device:                "cuda:0"
+# Evaluation
+eval:                  False # Render the optimized representation
+render_height:         2048 # Image height for rendering (aspect ratio is maintained)
+# Bit precision
+quantize:              False # Enable bit precision control of Gaussian parameters
+pos_bits:              16 # Bit precision of individual coordinate dimension
+scale_bits:            16 # Bit precision of individual scale dimension
+rot_bits:              16 # Bit precision of Gaussian orientation angle
+feat_bits:             16 # Bit precision of individual feature dimension
+gate_bits:             16 # Bit precision of per-Gaussian positive activity gate
+# Logging
+log_root:              "results"
+exp_name:              "default" # Path to the logging directory
+log_level:             "INFO"
+save_image_format:     "jpg"
+save_plot_format:      "jpg"
+vis_gaussians:         False # Visualize Gaussians during optimization
+save_image_steps:      100000 # Frequency of rendering intermediate results during optimization
+save_ckpt_steps:       100000 # Frequency of checkpointing during optimization
+eval_steps:            100
+# Target images
+gamma:                 1.0 # Optimize in a gamma-corrected space, modify with caution
+data_root:             "media"
+input_path:            "images/kodim01.png" # Path to an image file or a directory containing a texture stack
+downsample:            False # Load a downsampled version of the input image or texture stack as the optimization target to evaluate image upsampling performance
+downsample_ratio:      2.0
+# Mask-aware training (optional): fit Gaussians only inside a binary mask
+mask_path:             "" # Path to a binary mask image; empty = unmasked
+mask_outside_weight:   0.25 # lambda_out: per-pixel weight on render error outside the mask (lower = softer edge, higher = sharper)
+mask_hard_prune:       True # After training, drop any Gaussian whose center lands outside the mask
+mask_crop:             True # Crop training to the mask bounding box (+margin) for efficiency; positions map back to original coords on export
+mask_crop_margin:      0.06 # Margin around the mask bbox as a fraction of its size (keeps a hairline of background on interior sides for a sharp edge)
+mask_border_padding:   True # Add virtual outside-mask padding when the mask touches the image border, so border splats are penalized for bleeding past the frame
+mask_keep_band:        0 # Allow Gaussian centers within this many px of the mask boundary (0 = strict no-centers-outside). >0 keeps the edge-carrying Gaussians (recovers PSNR-in) while the loss still uses the original mask for a sharp edge.
+# Gaussians
+num_gaussians:         0 # Number of Gaussians. 0 = auto count calibrated for ~40 dB final PSNR
+init_scale:            1.5 # Initial Gaussian scale in number of pixels
+rasterizer:            "simple_sum" # Fixed in this branch
+disable_inverse_scale: False # Disable inverse Gaussian scale optimization
+ckpt_file:             ""
+disable_color_init:    False
+init_mode:             "gradient" # Legacy model-side init mode; train/export/viz paths override this with adaptive partition init
+init_random_ratio:     0.3 # Ratio of Gaussians with randomly initialized position
+smap_filter_size:      20 # Gaussian filter size for smoothing saliency maps
+# Loss functions
+l1_loss_ratio:         0.0
+l2_loss_ratio:         1.0
+ssim_loss_ratio:       0.0
+# Optimization
+disable_tiles:         False # Disable tile-based rendering (warning: optimization and rendering without tiles will be way slower)
+max_steps:             2800 # Maximum number of optimization steps
+pos_lr:                5.0e-4
+scale_lr:              2.0e-3
+rot_lr:                2.0e-3
+feat_lr:               5.0e-3
+gate_lr:               5.0e-3
+disable_lr_schedule:   False # Disable learning rate schedule and early stopping
+decay_ratio:           10.0
+check_decay_steps:     1000
+max_decay_times:       1
+decay_threshold:       1.0e-3
+disable_prog_optim:    True # Disable error-guided progressive optimization (start with all Gaussians)
+initial_ratio:         0.5
+add_steps:             500
+add_times:             4
+post_min_steps:        3000

requirements.txt

@@ -0,0 +1,20 @@
+# FlashImgs ZeroGPU Space dependencies.
+#
+# torch/torchvision are pinned to the cu128 (CUDA 12.8) builds the vendored
+# CUDA-extension wheels were compiled against. The wheels in ./wheels are built
+# for CPython 3.12 and Blackwell sm_120 (see README / NOTICE), so the Space must
+# run on python_version 3.12 (set in README front matter).
+#
+# gradio is installed by the Space runtime from the README `sdk_version`; do not
+# pin it here.
+
+--extra-index-url https://download.pytorch.org/whl/cu128
+
+torch==2.11.0+cu128
+torchvision==0.26.0+cu128
+
+spaces
+
+./wheels/flashimgs-0.1.0-py3-none-any.whl
+./wheels/fussim-0.3.14-cp312-cp312-linux_x86_64.whl
+./wheels/simple_sum_backend-0.1.0-cp312-cp312-linux_x86_64.whl

wheels/flashimgs-0.1.0-py3-none-any.whl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4bb56af72d0d4eccae186933802be17c4af66a566d5c6bca96a561a6c9be425b
+size 115508

wheels/fussim-0.3.14-cp312-cp312-linux_x86_64.whl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d2aa863d0aa2e8d9bb43c1a0920730580f0cbd28f0a3cb539062a8330442661d
+size 3213051

wheels/simple_sum_backend-0.1.0-cp312-cp312-linux_x86_64.whl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:30b7024ed2871b8ad25350851e10de11428e7b0d40191fcbcd2a12b1878faf3c
+size 688885