Informal list of possible future feature work in Juneau.  Please feel free to add to this list with ideas and put (+1 userid) next to items you're interested in.


  1. Investigate OpenAPI 3 support.  The Swagger API is currently at Swagger 2.0.  
  2. Proofread documentation.  It would be good to clean up areas that are confusing.    


  1. YAML support.
    This is kind of big though.  Essentially cloning the JSON serializers and parsers and converting them to use YAML syntax.
  2. Other possible languages:  BSON, Protobuf, Amazon Ion
  3. @JsonSchema validation support for all serializers and parsers.  
    This is also kind of big.  Basically adding SERIALIZER_validating and PARSER_validating settings (disabled by default) that would allow automatic schema validation of input and output just like we do for the OpenAPI serializer and parser. 
  4. FreeMarker integration.
  5. Test @Header("*") using maps/beans and related annotations.
  6. Simplify @Body annotation by merging @Schema into it.
  7. Test RestRequest.getRequest() and @Request as an annotation.
  8. Document RestRequest.getRequest().
  9. Find references to JsonSerializer.Simple


  1. Creating generic JSON objects
  2. Defining XML namespaces


  1. Packaging as WAR files (documentation or article?)
  2. Customizing OPTIONS pages
  3. Rendering form entry pages
  4. Using the ZipFileList response handler
  5. Implementing console-output pages in HTML
  6. Using configuration files
  7. Making a bean traversable
  8. Using the Queryable converter
  9. Sending raw output
  10. Retrieving raw input
  11. Accessing request query parameters
  12. Accessing request path variables
  13. Accessing request content
  14. Accessing request header values
  15. Accessing the path pattern remainder
  16. Creating ResourceGroup pages
  17. Using matchers to define multiple Java methods to the same path pattern
  18. Using the Remoteable API
  19. Sending a redirect request
  20. Changing the stylesheet used by the HTML serializer
  21. Using the Introspector API to invoke methods on Java objects through REST calls
  22. Customizing serializers and parsers at the method level
  23. Accessing config file values
  24. Accessing request query parameters on URL-Encoded FORM posts without triggering HTML body to be read
  25. Accessing localized messages
  26. Defining your own response handlers
  27. Guarding access to a servlet or method
  28. Handling servlet initialization errors
  29. Handling exceptions that occur during response processing
  30. Customizing logging
  31. Creating an ATOM feed
  32. Creating a REST API against a file system
  33. Creating a Docker REST API
  34. Creating a REST API for storing and retrieving images
  35. Creating a REST API for echoing requests
  36. Creating a Tumblr REST API
  37. Creating a Cloudant REST API
  38. Using onPreCall() to intercept requests before processing
  39. Using onPostCall() to intercept requests after processing
  40. Creating child resources programmatically
  41. Defining default request headers
  42. Defining default response headers
  43. Defining your own var-resolver variables
  44. Serving up static files inside the /htdocs embedded package
  45. Defining MIME types of files in the /htdocs folder using the createMimitypesFileTypeMap() method
  46. Defining the title and description of a servlet programmatically using getDescription() and getTitle().
  47. Setting properties programmatically using RestServlet.setProperty()
  48. Setting and saving config file properties
  49. Defining your own abstract subclass of RestServlet or RestServletDefault
  50. Adding GZip support
  51. Accessing environment variables in config files