1FLATPAK MANIFEST(5)            flatpak manifest            FLATPAK MANIFEST(5)
2
3
4

NAME

6       flatpak-manifest - Information for building an application
7

DESCRIPTION

9       Flatpak uses manifest, or recipe, files in a json or yaml format to
10       describe how an application and its bundled dependencies can be built
11       from sources. The manifest gets used by flatpak-builder.
12

FILE FORMAT

14       The top level of the manifest file describes global attributes of the
15       application, how it can be built, and the list of modules that need to
16       be built.
17
18   Toplevel properties
19       These are the properties that are accepted:
20
21       id or app-id (string)
22           A string defining the application id.
23
24       branch (string)
25           The branch to use when exporting the application. If this is unset
26           the defaults come from the default-branch option.
27
28           This key overrides both the default-branch key, and the
29           --default-branch commandline option. Unless you need a very
30           specific branchname (like for a runtime or an extension) it is
31           recommended to use the default-branch key instead, because you can
32           then override the default using --default-branch when building for
33           instance a test build.
34
35       default-branch (string)
36           The default branch to use when exporting the application. Defaults
37           to master.
38
39           This key can be overridden by the --default-branch commandline
40           option.
41
42       collection-id (string)
43           The collection ID of the repository, defaults to being unset.
44           Setting a globally unique collection ID allows the apps in the
45           repository to be shared over peer to peer systems without needing
46           further configuration. If building in an existing repository, the
47           collection ID must match the existing configured collection ID for
48           that repository.
49
50       extension-tag (string)
51           If building an extension, the tag for the extension point to use.
52           Since flatpak 0.11.4 a runtime may define multiple locations for
53           the same extension point with the intention that different branches
54           for the extension are mounted at each location. When building an
55           extension it is necessary to know what extension point to install
56           the extension to. This option resolves any ambiguity in which
57           extension point to choose. If not specified, the default choice is
58           to install into either the only location for the extension point or
59           into the location for the untagged extension point. If there are
60           multiple locations for the same extension point defined with
61           different tags then an error will occur.
62
63       token-type (integer)
64           The type of token needed to install this commit. Setting this to a
65           value greater than 0 implies that authentication will be needed to
66           install the flatpak.
67
68       runtime (string)
69           The name of the runtime that the application uses.
70
71       runtime-version (string)
72           The version of the runtime that the application uses, defaults to
73           master.
74
75       sdk (string)
76           The name of the development runtime that the application builds
77           with.
78
79       var (string)
80           Initialize the (otherwise empty) writable /var in the build with a
81           copy of this runtime.
82
83       metadata (string)
84           Use this file as the base metadata file when finishing.
85
86       command (string)
87           The filename or path to the main binary of the application. Note
88           that this is really just a single file, not a commandline. If you
89           want to pass arguments, install a shell script wrapper and use that
90           as the command.
91
92           Also note that the command is used when the application is run via
93           flatpak run, and does not affect what gets executed when the
94           application is run in other ways, e.g. via the desktop file or
95           D-Bus activation.
96
97       build-runtime (boolean)
98           Build a new runtime instead of an application.
99
100       build-extension (boolean)
101           Build an extension.
102
103       separate-locales (boolean)
104           Separate out locale files and translations to an extension runtime.
105           Defaults to true.
106
107       id-platform (string)
108           When building a runtime sdk, also create a platform based on it
109           with this id.
110
111       metadata-platform (string)
112           The metadata file to use for the platform we create.
113
114       writable-sdk (boolean)
115           If true, use a writable copy of the sdk for /usr. Defaults to true
116           if build-runtime is specified.
117
118       appstream-compose (boolean)
119           Run appstreamcli compose during cleanup phase. Defaults to true.
120
121       sdk-extensions (array of strings)
122           Install these extra sdk extensions in /usr.
123
124       platform-extensions (array of strings)
125           Install these extra sdk extensions when creating the platform.
126
127       base (string)
128           Start with the files from the specified application. This can be
129           used to create applications that extend another application.
130
131       base-version (string)
132           Use this specific version of the application specified in base. If
133           unspecified, this uses the value specified in branch
134
135       base-extensions (array of strings)
136           Install these extra extensions from the base application when
137           initializing the application directory.
138
139       inherit-extensions (array of strings)
140           Inherit these extra extension points from the base application or
141           sdk when finishing the build.
142
143       inherit-sdk-extensions (array of strings)
144           Inherit these extra extension points from the base application or
145           sdk when finishing the build, but do not inherit them into the
146           platform.
147
148       tags (array of strings)
149           Add these tags to the metadata file.
150
151       build-options (object)
152           Object specifying the build environment. See below for details.
153
154       modules (array of objects or strings)
155           An array of objects specifying the modules to be built in order.
156           String members in the array are interpreted as the name of a
157           separate json or yaml file that contains a module. See below for
158           details.
159
160       add-extensions (objects)
161           This is a dictionary of extension objects. The key is the name of
162           the extension. See below for details.
163
164       add-build-extensions (objects)
165           This is a dictionary of extension objects similar to
166           add-extensions. The main difference is that the extensions are
167           added early and are available for use during the build.
168
169       cleanup (array of strings)
170           An array of file patterns that should be removed at the end.
171           Patterns starting with / are taken to be full pathnames (without
172           the /app prefix), otherwise they just match the basename.
173
174       cleanup-commands (array of strings)
175           An array of commandlines that are run during the cleanup phase.
176
177       cleanup-platform (array of strings)
178           Extra files to clean up in the platform.
179
180       cleanup-platform-commands (array of strings)
181           An array of commandlines that are run during the cleanup phase of
182           the platform.
183
184       prepare-platform-commands (array of strings)
185           An array of commandlines that are run after importing the base
186           platform, but before applying the new files from the sdk. This is a
187           good place to e.g. delete things from the base that may conflict
188           with the files added in the sdk.
189
190       finish-args (array of strings)
191           An array of arguments passed to the flatpak build-finish command.
192
193       rename-desktop-file (string)
194           Any desktop file with this name will be renamed to a name based on
195           id during the cleanup phase.
196
197       rename-appdata-file (string)
198           Any appdata (metainfo) file with this name will be renamed to a
199           name based on id during the cleanup phase.
200
201       rename-mime-file (string)
202           Any mimetypes file with this name will me renamed to a name based
203           on id during the cleanup phase. (since 1.4.0)
204
205       rename-icon (string)
206           Any icon with this name will be renamed to a name based on id
207           during the cleanup phase. Note that this is the icon name, not the
208           full filenames, so it should not include a filename extension.
209
210       rename-mime-icons (array of string)
211           Any mime icons with any of these names will be renamed to a name
212           prefixed with id during the cleanup phase. Note that this is the
213           icon name, not the full filenames, so it should not include a
214           filename extension. (since 1.4.0)
215
216       appdata-license (string)
217           Replace the appdata (metainfo) project_license field with this
218           string. This is useful as the upstream license is typically only
219           about the application itself, whereas the bundled app can contain
220           other licenses too.
221
222       copy-icon (boolean)
223           If rename-icon is set, keep a copy of the old icon file.
224
225       desktop-file-name-prefix (string)
226           This string will be prefixed to the Name key in the main
227           application desktop file.
228
229       desktop-file-name-suffix (string)
230           This string will be suffixed to the Name key in the main
231           application desktop file.
232
233   Build Options
234       Build options specify the build environment of a module, and can be
235       specified globally as well as per-module. Options can also be specified
236       on a per-architecture basis using the arch property.
237
238       These are the properties that are accepted:
239
240       cflags (string)
241           This is set in the environment variable CFLAGS during the build.
242           Multiple specifications of this (in e.g. per-arch area) are
243           concatenated, separated by spaces.
244
245       cflags-override (boolean)
246           If this is true, clear cflags from previous build options before
247           adding it from these options.
248
249       cppflags (string)
250           This is set in the environment variable CPPFLAGS during the build.
251           Multiple specifications of this (in e.g. per-arch area) are
252           concatenated, separated by spaces.
253
254       cppflags-override (boolean)
255           If this is true, clear cppflags from previous build options before
256           adding it from these options.
257
258       cxxflags (string)
259           This is set in the environment variable CXXFLAGS during the build.
260           Multiple specifications of this (in e.g. per-arch area) are
261           concatenated, separated by spaces.
262
263       cxxflags-override (boolean)
264           If this is true, clear cxxflags from previous build options before
265           adding it from these options.
266
267       ldflags (string)
268           This is set in the environment variable LDFLAGS during the build.
269           Multiple specifications of this (in e.g. per-arch area) are
270           concatenated, separated by spaces.
271
272       ldflags-override (boolean)
273           If this is true, clear ldflags from previous build options before
274           adding it from these options.
275
276       prefix (string)
277           The build prefix for the modules (defaults to /app for applications
278           and /usr for runtimes).
279
280       libdir (string)
281           The build libdir for the modules (defaults to /app/lib for
282           applications and /usr/lib for runtimes).
283
284       append-path (string)
285           This will get appended to PATH in the build environment (with an
286           leading colon if needed).
287
288       prepend-path (string)
289           This will get prepended to PATH in the build environment (with an
290           trailing colon if needed).
291
292       append-ld-library-path (string)
293           This will get appended to LD_LIBRARY_PATH in the build environment
294           (with an leading colon if needed).
295
296       prepend-ld-library-path (string)
297           This will get prepended to LD_LIBRARY_PATH in the build environment
298           (with an trailing colon if needed).
299
300       append-pkg-config-path (string)
301           This will get appended to PKG_CONFIG_PATH in the build environment
302           (with an leading colon if needed).
303
304       prepend-pkg-config-path (string)
305           This will get prepended to PKG_CONFIG_PATH in the build environment
306           (with an trailing colon if needed).
307
308       env (object)
309           This is a dictionary defining environment variables to be set
310           during the build. Elements in this override the properties that set
311           the environment, like cflags and ldflags. Keys with a null value
312           unset the corresponding variable.
313
314       secret-env (array of strings)
315           This is a array defining which host environment variables is
316           transfered to build-commands or post-install environment.
317
318       build-args (array of strings)
319           This is an array containing extra options to pass to flatpak build.
320
321       test-args (array of strings)
322           Similar to build-args but affects the tests, not the normal build.
323
324       config-opts (array of strings)
325           This is an array containing extra options passed to the build
326           system during configuration.
327
328       secret-opts (array of strings)
329           This is an array of options that will be passed to configure, meant
330           to be used to pass secrets through host environment variables. Put
331           the option with an environment variables and will be resolved
332           beforehand. '-DSECRET_ID=$CI_SECRET'
333
334       make-args (array of strings)
335           An array of extra arguments that will be passed to make
336
337       make-install-args (array of strings)
338           An array of extra arguments that will be passed to make install
339
340       strip (boolean)
341           If this is true (the default is false) then all ELF files will be
342           stripped after install.
343
344       no-debuginfo (boolean)
345           By default (if strip is not true) flatpak-builder extracts all
346           debug info in ELF files to a separate files and puts this in an
347           extension. If you want to disable this, set no-debuginfo to true.
348
349       no-debuginfo-compression (boolean)
350           By default when extracting debuginfo we compress the debug
351           sections. If you want to disable this, set no-debuginfo-compression
352           to true.
353
354       arch (object)
355           This is a dictionary defining for each arch a separate build
356           options object that override the main one.
357
358   Extension
359       Extension define extension points in the app/runtime that can be
360       implemented by extensions, supplying extra files which are available
361       during runtime..
362
363       These are the properties that are accepted:
364
365       directory (string)
366           The directory where the extension is mounted. If the extension
367           point is for an application, this path is relative to /app,
368           otherwise it is relative to /usr.
369
370       bundle (boolean)
371           If this is true, then the data created in the extension directory
372           is omitted from the result, and instead packaged in a separate
373           extension.
374
375       remove-after-build (boolean)
376           If this is true, the extension is removed during when finishing.
377           This is only interesting for extensions in the add-build-extensions
378           property.
379
380       Additionally the standard flatpak extension properties are supported,
381       and put directly into the metadata file: autodelete, no-autodownload,
382       subdirectories, add-ld-path, download-if, enable-if, merge-dirs,
383       subdirectory-suffix, locale-subset, version, versions. See the flatpak
384       metadata documentation for more information on these.
385
386   Module
387       Each module specifies a source that has to be separately built and
388       installed. It contains the build options and a list of sources to
389       download and extract before building.
390
391       Modules can be nested, in order to turn related modules on and off with
392       a single key.
393
394       These are the properties that are accepted:
395
396       name (string)
397           The name of the module, used in e.g. build logs. The name is also
398           used for constructing filenames and commandline arguments,
399           therefore using spaces or '/' in this string is a bad idea.
400
401       disabled (boolean)
402           If true, skip this module
403
404       sources (array of objects or strings)
405           An array of objects defining sources that will be downloaded and
406           extracted in order. String members in the array are interpreted as
407           the name of a separate json or yaml file that contains sources. See
408           below for details.
409
410       secret-env (array of strings)
411           An array defining which host environment variables is transfered to
412           build-commands or post-install environment.
413
414       config-opts (array of strings)
415           An array of options that will be passed to configure
416
417       secret-opts (array of strings)
418           An array of options that will be passed to configure, meant to be
419           used to pass secrets through host environment variables. Put the
420           option with an environment variables and will be resolved
421           beforehand. '-DSECRET_ID=$CI_SECRET'
422
423       make-args (array of strings)
424           An array of arguments that will be passed to make
425
426       make-install-args (array of strings)
427           An array of arguments that will be passed to make install
428
429       rm-configure (boolean)
430           If true, remove the configure script before starting build
431
432       no-autogen (boolean)
433           Ignore the existence of an autogen script
434
435       no-parallel-make (boolean)
436           Don't call make with arguments to build in parallel
437
438       install-rule (string)
439           Name of the rule passed to make for the install phase, default is
440           install
441
442       no-make-install (boolean)
443           Don't run the make install (or equivalent) stage
444
445       no-python-timestamp-fix (boolean)
446           Don't fix up the *.py[oc] header timestamps for ostree use.
447
448       cmake (boolean)
449           Use cmake instead of configure (deprecated: use buildsystem
450           instead)
451
452       buildsystem (string)
453           Build system to use: autotools, cmake, cmake-ninja, meson, simple,
454           qmake
455
456       builddir (boolean)
457           Use a build directory that is separate from the source directory
458
459       subdir (string)
460           Build inside this subdirectory of the extracted sources
461
462       build-options (object)
463           A build options object that can override global options
464
465       build-commands (array of strings)
466           An array of commands to run during build (between make and make
467           install if those are used). This is primarily useful when using the
468           "simple" buildsystem. Each command is run in /bin/sh -c, so it can
469           use standard POSIX shell syntax such as piping output.
470
471       post-install (array of strings)
472           An array of shell commands that are run after the install phase.
473           Can for example clean up the install dir, or install extra files.
474
475       cleanup (array of strings)
476           An array of file patterns that should be removed at the end.
477           Patterns starting with / are taken to be full pathnames (without
478           the /app prefix), otherwise they just match the basename. Note that
479           any patterns will only match files installed by this module.
480
481       ensure-writable (array of strings)
482           The way the builder works is that files in the install directory
483           are hard-links to the cached files, so you're not allowed to modify
484           them in-place. If you list a file in this then the hardlink will be
485           broken and you can modify it. This is a workaround, ideally
486           installing files should replace files, not modify existing ones.
487
488       only-arches (array of strings)
489           If non-empty, only build the module on the arches listed.
490
491       skip-arches (array of strings)
492           Don't build on any of the arches listed.
493
494       cleanup-platform (array of strings)
495           Extra files to clean up in the platform.
496
497       run-tests (boolean)
498           If true this will run the tests after installing.
499
500       test-rule (string)
501           The target to build when running the tests. Defaults to "check" for
502           make and "test" for ninja. Set to empty to disable.
503
504       test-commands (array of strings)
505           Array of commands to run during the tests.
506
507       modules (array of objects or strings)
508           An array of objects specifying nested modules to be built before
509           this one. String members in the array are interpreted as names of a
510           separate json or yaml file that contains a module.
511
512   Sources
513       These contain a pointer to the source that will be extracted into the
514       source directory before the build starts. They can be of several types,
515       distinguished by the type property.
516
517       Additionally, the sources list can contain a plain string, which is
518       interpreted as the name of a separate json or yaml file that is read
519       and inserted at this point. The file can contain a single source, or an
520       array of sources.
521
522       All sources
523           only-arches (array of strings)
524               If non-empty, only build the module on the arches listed.
525
526           skip-arches (array of strings)
527               Don't build on any of the arches listed.
528
529           dest (string)
530               Directory inside the source dir where this source will be
531               extracted.
532
533       Archive sources (tar, zip)
534           type
535               "archive"
536
537           path (string)
538               The path of the archive
539
540           url (string)
541               The URL of a remote archive that will be downloaded. This
542               overrides path if both are specified.
543
544           mirror-urls (array of strings)
545               A list of alternative urls that are used if the main url fails.
546
547           referer (string)
548               Sets the HTTP "Referer" header when downloading the archive.
549
550           git-init (boolean)
551               Whether to initialise the repository as a git repository.
552
553           archive-type (string)
554               The type of archive if it cannot be guessed from the path.
555               Possible values are "rpm", "tar", "tar-gzip", "tar-compress",
556               "tar-bzip2", "tar-lzip", "tar-lzma", "tar-lzop", "tar-xz",
557               "tar-zst", "zip" and "7z".
558
559           md5 (string)
560               The md5 checksum of the file, verified after download
561
562               Note that md5 is no longer considered a safe checksum, we
563               recommend you use at least sha256.
564
565           sha1 (string)
566               The sha1 checksum of the file, verified after download
567
568               Note that sha1 is no longer considered a safe checksum, we
569               recommend you use at least sha256.
570
571           sha256 (string)
572               The sha256 checksum of the file, verified after download
573
574           sha512 (string)
575               The sha512 checksum of the file, verified after download
576
577           strip-components (integer)
578               The number of initial pathname components to strip during
579               extraction. Defaults to 1.
580
581           dest-filename (string)
582               Filename to for the downloaded file, defaults to the basename
583               of url.
584
585       Git sources
586           type
587               "git"
588
589           path (string)
590               The path to a local checkout of the git repository. Due to how
591               git-clone works, this will be much faster than specifying a URL
592               of file:///...
593
594           url (string)
595               URL of the git repository. This overrides path if both are
596               specified. When using git via SSH, the correct syntax is
597               ssh://user@domain/path/to/repo.git.
598
599           branch (string)
600               The branch to use from the git repository. As of 1.2.3 this
601               will try to auto-detect the upstream default branch. Previously
602               this defaulted to master.
603
604           tag (string)
605               The tag to use from the git repository
606
607           commit (string)
608               The commit to use from the git repository. If branch is also
609               specified, then it is verified that the branch/tag is at this
610               specific commit. This is a readable way to document that you're
611               using a particular tag, but verify that it does not change.
612
613           disable-fsckobjects (boolean)
614               Don't use transfer.fsckObjects=1 to mirror git repository. This
615               may be needed for some (broken) repositories.
616
617           disable-shallow-clone (boolean)
618               Don't optimize by making a shallow clone when downloading the
619               git repo.
620
621           disable-submodules (boolean)
622               Don't checkout the git submodules when cloning the repository.
623
624       Bzr sources
625           type
626               "bzr"
627
628           url (string)
629               URL of the bzr repository
630
631           revision (string)
632               A specific revision to use in the branch
633
634       Svn sources
635           type
636               "svn"
637
638           url (string)
639               URL of the svn repository, including branch/tag part
640
641           revision (string)
642               A specific revision number to use
643
644       Directory sources
645           type
646               "dir"
647
648           path (string)
649               The path of a local directory whose content will be copied into
650               the source dir. Note that directory sources don't currently
651               support caching, so they will be rebuilt each time.
652
653           skip (array of strings)
654               Source files to ignore in the directory.
655
656       File sources
657           type
658               "file"
659
660           path (string)
661               The path of a local file that will be copied into the source
662               dir
663
664           url (string)
665               The URL of a remote file that will be downloaded and copied
666               into the source dir. This overrides path if both are specified.
667
668           mirror-urls (array of strings)
669               A list of alternative urls that are used if the main url fails.
670
671           referer (string)
672               Sets the HTTP "Referer" header when downloading the file.
673
674           md5 (string)
675               The md5 checksum of the file, verified after download. This is
676               optional for local files.
677
678               Note that md5 is no longer considered a safe checksum, we
679               recommend you use at least sha256.
680
681           sha1 (string)
682               The sha1 checksum of the file, verified after download. This is
683               optional for local files.
684
685               Note that sha1 is no longer considered a safe checksum, we
686               recommend you use at least sha256.
687
688           sha256 (string)
689               The sha256 checksum of the file, verified after download. This
690               is optional for local files.
691
692           sha512 (string)
693               The sha512 checksum of the file, verified after download. This
694               is optional for local files.
695
696           dest-filename (string)
697               Filename to use inside the source dir, default to the basename
698               of path.
699
700       Script sources
701           This is a way to create a shell (/bin/sh) script from an inline set
702           of commands.
703
704           type
705               "script"
706
707           commands (array of strings)
708               An array of shell commands that will be put in a shellscript
709               file
710
711           dest-filename (string)
712               Filename to use inside the source dir, default to autogen.sh.
713
714       Inline data sources
715           This is a way to create a file with given contents.
716
717           type
718               "inline"
719
720           dest-filename (string)
721               Filename to use inside the source dir.
722
723           contents (string)
724               Text data that will be put in the file.
725
726           base64 (boolean)
727               Whether content is base64-encoded.
728
729       Shell sources
730           This is a way to create/modify the sources by running shell
731           commands.
732
733           type
734               "shell"
735
736           commands (array of strings)
737               An array of shell commands that will be run during source
738               extraction
739
740       Patch sources
741           type
742               "patch"
743
744           path (string)
745               The path of a patch file that will be applied in the source dir
746
747           paths (array of strings)
748               An list of paths to a patch files that will be applied in the
749               source dir, in order
750
751           strip-components (integer)
752               The value of the -p argument to patch, defaults to 1.
753
754           use-git (boolean)
755               Whether to use "git apply" rather than "patch" to apply the
756               patch, required when the patch file contains binary diffs.
757
758           use-git-am (boolean)
759               Whether to use "git am" rather than "patch" to apply the patch,
760               required when the patch file contains binary diffs. You cannot
761               use this at the same time as use-git.
762
763           options (array of strings)
764               Extra options to pass to the patch command.
765
766       Extra data sources
767           type
768               "extra-data"
769
770           filename (string)
771               The name to use for the downloaded extra data
772
773           url (string)
774               The url to the extra data.
775
776           sha256 (string)
777               The sha256 of the extra data.
778
779           size (number)
780               The size of the extra data in bytes.
781
782           installed-size (string)
783               The extra installed size this adds to the app (optional).
784

BUILD ENVIRONMENT

786       When building the application each command is run in a separate sandbox
787       with access to only the things required for it. This section describes
788       the details of the sandbox. Any options here can be overridden globally
789       or per-module with the build-args option (although such manifest will
790       not work if you start flatpak-builder with --sandbox).
791
792   Filesystem
793       Each module is built in its own build directory, stored in a sub
794       directory called build/$modulename-$count in the state dir (which is
795       typically .flatpak-builder/). Additionally there is a symlink
796       build/$modulename to the latest version. In order to generate
797       reproducible builds this directory is also mounted as
798       /run/build/$modulename in the sandbox (or
799       /run/build-runtime/$modulename when building runtimes). This is used as
800       current working directory for all build ops.
801
802       The destination directory for installation is accessible for writing at
803       the place it will seen at runtime. In the case of a regular application
804       this will be /app. If building a runtime it will instead be /usr, and
805       when building an extension it will be at the extensionpoint directory
806       somewhere below /app (for app extension) or /usr (for runtime
807       extensions).
808
809       Additionally the there will be (as needed, depending on what is
810       building) read-only mounts of the sdk at /usr, sdk extensions below
811       that, and the application at /app. No other filesystem access is
812       available.
813
814   Environment
815       The environment can be modified in several ways in the manifest, but
816       the default values are:
817
818       FLATPAK_ID
819           The id of the application currently building.
820
821       FLATPAK_ARCH
822           The architecture currently building.
823
824       FLATPAK_DEST
825           The path to where the current build should install into. This is
826           /app for application builds.
827
828       FLATPAK_BUILDER_N_JOBS
829           The number of jobs that flatpak-builder would normally use for make
830           -j. Defaults to ncpus unless the module disabled parallel make.
831
832       FLATPAK_BUILDER_BUILDDIR
833           The path to the build directory of the module currently building.
834           This is normally /run/build/$MODULE.
835
836       PATH
837           /app/bin:/usr/bin
838
839       LD_LIBRARY_PATH
840           /app/lib
841
842       PKG_CONFIG_PATH
843           /app/lib/pkgconfig:/app/share/pkgconfig:/usr/lib/pkgconfig:/usr/share/pkgconfig
844
845       ACLOCAL_PATH
846           /app/share/aclocal
847
848       C_INCLUDE_PATH
849           /app/include
850
851       CPLUS_INCLUDE_PATH
852           /app/include
853
854       LDFLAGS
855           -L/app/lib
856
857       LC_ALL
858           en_US.utf8
859
860   Permissions
861       Builds have the --allow=devel and --allow=multiarch permissions that
862       regular flatpak runs don't have by default. This limits the syscall
863       filtering that is normally done so development tools like debuggers
864       work. Otherwise the build sandbox is very limited, for example there is
865       no network access.
866

EXAMPLES

868       $ flatpak-builder my-app-dir manifest.json
869
870       Example manifest file:
871
872           {
873               "id": "org.test.TestApp",
874               "runtime": "org.freedesktop.Platform",
875               "runtime-version": "1.2",
876               "sdk": "org.freedesktop.Sdk",
877               "command": "test",
878               "clean": [ "/include", "*.la" ],
879               "build-options" : {
880                   "cflags": "-O2 -g",
881                   "cxxflags": "-O2 -g",
882                   "env": {
883                       "V": "1"
884                   },
885                   "arch": {
886                       "x86_64": {
887                           "cflags": "-O3 -g",
888                       }
889                   }
890               },
891               "modules": [
892                   {
893                       "name": "pygobject",
894                       "config-opts": [ "--disable-introspection" ],
895                       "sources": [
896                           {
897                               "type": "archive",
898                               "url": "http://ftp.gnome.org/pub/GNOME/sources/pygobject/2.28/pygobject-2.28.6.tar.xz",
899                               "sha256": "fb8a1d4f665130a125011659bd347c7339c944232163dbb9a34fd0686577adb8"
900                           },
901                           {
902                               "type": "patch",
903                               "path": "required-pygobject-fix.patch"
904                           },
905                           {
906                               "type": "file",
907                               "path": "pygobject-extra-file",
908                               "dest-filename": "extra-file"
909                           }
910                       ]
911                   },
912                   {
913                       "name": "babl",
914                       "build-options" : { "cxxflags": "-O2 -g -std=c++11" },
915                       "cleanup": [ "/bin" ],
916                       "sources": [
917                           {
918                               "type": "git",
919                               "url": "https://gitlab.gnome.org/GNOME/babl.git"
920                           }
921                       ]
922                   },
923                   {
924                       "name": "testapp",
925                       "sources": [
926                           {
927                               "type": "bzr",
928                               "url": "lp:testapp"
929                           }
930                       ]
931                   }
932               ]
933           }
934

SEE ALSO

936       flatpak-builder(1)
937
938
939
940flatpak                                                    FLATPAK MANIFEST(5)
Impressum