TrustRadius Insights for NativeScript are summaries of user sentiment data from TrustRadius reviews and, when necessary, third party data sources.
Pros
Extensive repository of plugins: Many users appreciate the extensive repository of plugins available in NativeScript, which allows them to enhance their development speed. This feature has been praised by numerous reviewers as it enables developers to quickly add functionality to their apps without having to build everything from scratch.
Flexibility of architectural choices: The flexibility of NativeScript's four architectural choices - JavaScript, TypeScript, Angular, and Vue - is highly valued by users. This flexibility has been mentioned by a significant number of reviewers who appreciate being able to choose the framework they are most comfortable with and easily transition from prototype to final product.
Native API access and performance: The fact that NativeScript offers 100-day zero Native API access is seen as a major advantage by many users. Multiple reviewers mention this feature as it allows them to leverage the full power of native UI and achieve better performance compared to other frameworks like Ionic or PhoneGap. This capability gives developers more flexibility and control over their app's performance.
We used NativeScript as per customer requests to implement mobile and web-based cross-platform applications used in the customer service industry. The customer wanted to implement the application in the Angular web framework and then port it to Android. We chose NativeScript as one of its main selling points was the cross-compatibility with writing the code in an Angular web app.
Pros
Teach the basics of the framework
Integrate to existing Angular project
Cons
Lots of bugs in the android build, visual and interface wise as well.
Android functions were missing which was crucial
Poor plugin support, buggy plugins
Low response time to new android features
Likelihood to Recommend
I gotta be honest, after a PoC period, we choose to rewrite the whole application in a different cross-platform app. Our developers had to invest a lot of time and effort to debug a lot of plugin-related issues, which we needed to utilize the android mobile phone capabilities. QR reader, special visualizations, and fine-tuning were really hard and often resulted in writing native Android code instead of using the shared Angular code. In the end, we think that writing a standalone Android app and an Angular app would have been a better alternative, as the shared code base was so unreliable that it did not save us any time.
NativeScript (NS) is JavaScript that runs on a system-specific JSVM (V8 for Android, WebKit iOS). And everything would be sad if not for one thing - NS provides access to all system APIs. Moreover, NS has full support for the Angular framework. Mobile apps that we built with NS have full access to the platform APIs as if they were developed in XCode or Android Studio. Also with the help of NS we can also include third-party libraries from resources such as Cocoapods, Android Arsenal, Maven, and npm.js into applications without creating additional layers.
Pros
Access to the entire native API
Support for native iOS and Android libraries
Cross-platform declarative UI and source code
Powerful data visualization with native UI tools provided
Cons
The need to know the native Android and iOS APIs to access device hardware and other platform-specific functionality
Not all user interface components are available for free
NativeScript has no HTML and DOM, which requires some deep knowledge of different UI tools to be implemented instead
Likelihood to Recommend
NativeScript allows to easily integrate with native APIs by threading models. Moreover, the framework itself can be integrated with Angular, VueJS and JavaScript due to the fact that it was built on based on these frameworks. It allows you to easily maintain if you projects are based on these frameworks. Therefore, for the development of cross-platform applications it can be very handy!
In an effort to move from having separate projects for Angular web development and Android Studio for Andriod app development, I have been trying to replace the multiple projects with a single NativeScript project and add support for iOS devices. I have worked as a consultant for other organizations who also tried to use NativeScript for the exact same reason. One of the prior organizations was a large US government department, and another was a private organization who facilitates the trading of goods internationally.
Pros
Executes really fast compared to other alternatives
Compiles down to native code and runs as a native app
Provides a way to split custom content, including CSS styles, into separate files per target platform
Cons
The ABSOLUTE WORST documentation I have ever seen for an environment which advertises direct involvement with Google and other vendors. Their website content appears to be written once as a version comes out, and then is never updated again as follow-on versions with significant changes are released.
Examples provided are often written from an expert's view, making far too many assumptions, and containing too much outdated content, to be useful to any developer who is just learning the environment.
Some areas of considerable interest, such as the development of composite plugins (draw on the use of existing components as opposed to new native components), are void of ANY useful support.
Support is left up to the use of stackoverflow.com questions and answers, and several of those who respond frequently, do so with language which comes across in an arrogant manner, and only serves to help in a specific instance, not in a global manner which would be useful to all.
The description of the environment is misleading. One is often led to believe that use of NativeScript will significantly reduce development effort and time. I would venture to guess that in most cases, this is untrue. A lot of effort is spent trying to keep the web app and the mobile apps at the same level of development, because the NativeScript components DO NOT support web pages. The user interface of a web app is still almost entirely new development.
The appearance of an Android mobile app is only like that of an iOS mobile app about 90% of the time. You cannot develop an app in NativeScript for an Android device, and expect it to look the same for iOS apps. Organizations who read about NativeScript, are misled into believing that the will be able to reduce staff by eliminating all Android developers or all iOS developers. To do so, is unwise, and in most cases, I believe that organizations will find it easier to develop for one mobile platform and then have the other mobile platform follow one version behind.
NativeScript advertises that it provides great support for Angular and other environments. While I cannot speak directly to those other environments, I can say that the integration between NativeScript and Angular is CLUNKY and PROBLEMATIC! What is easily accomplished in Angular, is a headache in NativeScript, and ends up degrading the quality of use within Angular. For example, Angular allows for developers to very easily develop components which reduce code duplication. Developing a NativeScript UI plugin (aka composite plugin) is made so difficult through the abundance of BAD information on the NativeScript website and manual operations to get it to work within Angular, that it defeats the purpose of building them. I see developers spending more time trying to fix the integration of a UI plugin than they spend in actually using the plugin.
Likelihood to Recommend
NativeScript by itself, appears to be a reasonable environment for the development of <b>simple</b> apps between a web app and mobile apps. Do not read their white papers and accomplishments of their development team members, but rather what external developers are saying.
If you are looking to add the use of NativeScript to an existing environment, give your developers several months to work through several significant scenarios <b>individually</b> in full-fledged (not stubbed) proofs-of-concept. Impress upon those developers, the need to delve deep into the construction of NativeScript UI plugins which require interaction with other areas of functionality within the environment. Even if you believe that the out-of-the-box functionality of NativeScript appears sufficient, ask each of your developers to attempt the development of a couple of NativeScript plugins which interact with the native functionality of both Android and iOS.
Once your development has had ample (or excessive) time to provide you with working proofs-of-concept, <b>please listen intently</b> to all of the concerns posed by those developers. Do not accept a summary report of their efforts. I cannot stress this last one enough, because this is often when large development teams fail, and/or end up going way over budget.
We are testing NativeScript to see if it will be a good fit for the next version of our app. We have an e-learning education platform focused on mobile. Our current version is built on ionic v1, and we are looking for a better alternative. Our app needs to be offline first, but the courses and content are downloaded from the internet. The app has lots of gamification features. It needs to be much slicker than it is now in the current stack.
Pros
True native app. The app uses native components and that is quite noticeable in the overall performance of the app. NativeScript is also awesome in the way we can access the native APIs, so we are never really constrained by the framework. If we need, we can just dive into the native APIs without leaving our environment and language (JS).
Cross-platform. Builds for Android and iOS. It deals with the platforms differences very well.
Support for Vue.js. Even though it is just a community effort, the NativeScript-Vue plugin is the best alternative to build native Apps with Vue.js. That was a major factor to go with NativeScript.
Cons
Web build. It is still hard to share code with a web build. In our case, we want to build a web app with pretty much the same functionality. Other frameworks are stronger at this point.
No hot-reload. It still takes a couple of seconds to test an app. React Native does it better... With NS-Vue, the live-reload is even more fragile...
Tooling. Overall, NS could use better tooling. Again, RN does it better.
Better NS-Vue support. It is improving very well, considering it is a community effort. I see NS organization 100% supporting NS-Vue, but it is still not at the same level as NS-Ng, for instance.
Likelihood to Recommend
<div>I would recommend for building native apps for iOS or Android if 1) the developers come from a web dev background; 2) the company can't afford separate teams for Android and iOS; 3) the team wants to use Vue.js.
</div><div>
</div><div>I would not recommend if the app needs a web version and is simple enough to be a hybrid app.
We are using NativeScript on a single mobile project at the moment. It is the framework which supports development of this entire project for our client. In particular, we are using NativeScript with Angular 5, to leverage the current skills of our front-end development team. We also have an internal app to track our knowledge sharing events that we are developing with NativeScript.
Pros
NativeScript allows our front-end developers to build actually native mobile apps with the javascript we already know well.
It is very quick to get started using NativeScript. We can generally onboard a new developer into the project in just a day or two.
The open source community surrounding NativeScript allows our team to find solutions to open issues quickly, as well as give back by fixing some issues ourselves. Work can progress quicker with the plugins other developers have already built.
Cons
The frequency of updates can make it hard to stay fixed to a common version. I found that there were so many improvements happening that it was worth bumping versions and adjusting the code at least every 3 months. This added extra development time, which also added stress. The benefit is worth it, but it's important to keep in mind that sometimes even a bugfix version bump will require some code changes.
We also found the fractured dependencies hard to keep up with at times. The nativesript-cli, tns-android, tns-ios and nativescript-angular dependencies all have their own release cycles that are close together, but not tied together, and that has downsides when prioritising upgrades during a release cycle. Again, the benefit to upgrading is worth it, but staggered releases do add additional complications.
Documentation is good, but could be better. Over the past year, this has been greatly improved, but there is still a delay between the adding or refactoring of features and the updates to the documentation.
The plugin ecosystem is open source, which is good, but as with your own project, the authors of these plugins also have to keep up to date with the changes in the repos, and that isn't always done in a timely fashion.
Likelihood to Recommend
As with any mobile app, the most important decision to make first is whether you really need a mobile app at all. If you are just building a web app with some user data persistence, then perhaps a progressive web app is all you need. Where NativeScript shines is in building apps that use more than the standard web APIs, and really provide value to your users in how they interact with the device APIs.
Additionally, consider what javascript framework your team is most comfortable using before starting your NativeScript project. There are flavours available for standard JS, Angular, and Vue. Angular is often the best documented, and both JS and Angular are quite stable. NativeScript + Vue is new, and there are still many bugs, but for simple apps, you can accomplish a lot without trouble. The best thing is to choose based on what your team already knows, and this will speed up your development process.
We are a consulting company and use NativeScript for apps internally and externally for customers. We chose to use NativeScript as a mobile app development platform because of its native performance, native UI generation, and ease of cross-platform mobile development. Furthermore, we can leverage existing skills on our development teams (Angular, TypeScript, and CSS) to create native mobile apps. This was the first platform we tried that was easy to get started with, and provided the least amount of friction for developing mobile apps.
Pros
NativeScript allows you to build on skills many development teams already have: HTML, JavaScript, and CSS. Many developers understand the paradigm of web development where you have HTML, JavaScript, and CSS to define an application's behavior. NativeScript apps are similar. By using a similar paradigm of development, it enables web developers to quickly jump into their first app, write it quickly, and see the results on iOS and Android.
The NativeScript Playground sets NativeScript apart from other technologies. The NativeScript Playground is a browser-based environment for developing simple NativeScript apps. It’s a great place to get started learning NativeScript, as you can develop apps without needing to install the various SDKs and tools needed for native iOS and Android development. All you need is your browser, and an Android or iOS mobile device connected to the internet to get started. We use the NativeScript Playground to quickly prototype apps. It's an extremely powerful tool.
NativeScript provides abstracted UI and component APIs to access native iOS and Android hardware and UI components. This accelerates development because you can write a singular UI and business logic code for both iOS and Android, thus saving time. At the same time, you have the ability to access native SDK/APIs of the underlying platforms through JavaScript.
NativeScript has three flavors of development: NativeScript Core, Angular, and VueJS. NativeScript Core uses XML, JavaScript, and CSS to build native apps. But, if your developers already know Angular or VueJS, then you can build NativeScript apps using Angular/VueJS development paradigms.
There are dozens of online resources for getting started, troubleshooting, and staying up-to-date with NativeScript: forums, slack channel, twitter, online docs, NativeScript snacks, NativeScripting, blogs, etc. The community has been very strong, and continues to be a shining star NativeScript.
Cons
If users jump directly into NativeScript Angular and are not familiar with NativeScript or Angular yet, it can be difficult to understand where NativeScript ends and Angular begins. This can be confusing.
Likelihood to Recommend
NativeScript is great for line of business apps, quick prototypes, and production apps. NativeScript isn't designed for heavy 3D graphics and gaming apps, as other platforms like Unity do this well and are highly optimized.
I currently use NativeScript for multiple applications that are in various stages of development. In my opinion, NativeScript is one of the best if not the best frameworks to write Android and iOS Applications. With NativeScript I'm able to reuse concepts and knowledge of existing frameworks such as Angular or Vue.js to build Applications that actually use native elements and have native performance.
A common problem with multi-platform development is eventually you will encounter a situation where the framework doesn't have a feature you need to complete a task. This is true for all multi-platform frameworks, including NativeScript. However, with NativeScript you have access to the native API for iOS and Android. This allows us as developers to solve our own problems and not lose momentum whereas other frameworks we would be at the mercy of plugin developers or have to write Java and/or Objective C code ourselves to sometimes solve very small but frustrating tasks.
Pros
Code Reuse - With NativeScript you can share code between Native and Mobile Applications.
Native APIs - being able to access Native APIs allows us as developers to write applications in one language instead of jumping between the Java/Objective C apps are written in TypeScript or JavaScript.
Ease of use - NativeScript SideKick makes working with NativeScript a breeze and allows us to get an application set up for development in a few minutes.
Cons
Occasionally there are inconsistencies when it comes to styling and layouts between Android and iOS, this can be frustrating especially in the beginning because you are usually working with one platform and then switch to the other only to have layout issues.
New releases sometimes are buggy.
Likelihood to Recommend
NativeScript is well suited for most smartphone applications, I'm using it for a motion sensing application, a Roku remote and a streaming music service application, however, it is not for game development.
VU
Verified User
Employee in Information Technology (201-500 employees)
I work at a fitness based startup. Our app, "AnyGo" is built entirely using NativeScript. I was the one who proposed to the team, to use NativeScript. And today when I look back, I'm glad that I found NativeScript. We were able to launch our app in 6 months, all thanks to NativeScript. I worked on the app, while 3 other developers built the backend on NodeJS.
Pros
NativeScript has a large repository of plugins at market.nativescript.org for the times when you want to boost your development speed.
NativeScript gives you 100% day zero Native API access.
NativeScript doesn't use any webview to render the UI. So you get Native UI, and therefore better performance, when compared to things like ionic or phone gap.
With NativeScript you get 4 architectural choices, JavaScript, TypeScript, Angular and Vue. Choose the one you are comfortable with.
Cons
Nativescript runs everything on a single thread. i.e., the UI thread. If you want to offload some processing, you have to use web workers. This experience can be improved in the future releases.
Currently NativeScript only have hot reload when you change the UI file or Css file. There is no hot reload when you change Js/Ts file, unlike Google's Flutter. This is also something which NativeScript will get in the future releases.
In current version of NativeScript, there is no livesync when building with webpack. This feature will be added with NativeScript 4.x. (an RC version for 4.x is already available)
Likelihood to Recommend
When you want to target Web and Mobile (iOS + Android), using a single code base. Then you can use NativeScript Angular or NativeScript Vue.
If your app is going to do a lot of heavy lifting in the background, requires building widgets that can be added on homescreen, or simply is going to be a service, which doesn't require UI, then NativeScript is not an ideal fit for that project.
As a very small development shop, NativeScript allows us to create cross platform "native" mobile applications for Android and iOS while using a single web skillset rather than needing to learn Java, Objective-C, or Swift. NativeScript with Angular is being used and the single skillset for development helps to reduce the cost and barrier to entry for mobile application development.
Pros
Native mobile applications built with NativeScript that do not rely on a WebView component result in extremely fast performance and a happy user experience.
Being able to use JavaScript, TypeScript, Angular, or Vue.js gives the developers options when it comes to development.
NativeScript has a lot of plugins for features such as charting that would otherwise be very complicated to implement in iOS and Android if not using NativeScript.
Cons
The documentation could be improved to be more consistent across all supported frameworks like Angular, Vue.js, and Core.
The application binary size could be reduced to be more in line with pure native and other similar frameworks.
Likelihood to Recommend
NativeScript is well suited for most mobile development. Being that it supports Android and iOS with either Angular, Vue.js, and TypeScript or JavaScript, it covers a lot of developer possibilities. If the developer has prior experience with React, it may be more logical to explore React Native to meet an already existing skill set. Likewise if the developer has prior C# experience it might be better to choose Xamarin.
Our organization uses NativeScript to build different mobile applications for clients with different needs. NativeScript has been a great fit for us for the last couple of years, as it allows us to move forward quickly delivering high-quality applications in a lot less time than it would take if we had to develop two separate codebases for the two main platforms.
Pros
Easy to use abstactions for common elements such as action bars, tab views etc.
Allows accessing native APIs within JavaScript, so if anything is missing from the core framework, we don't have to wait for an update, we can just implement it straight away.
The choices when choosing a framework (or no framework) to be used. NativeScript works with plain JavaScript, plain Typescript, Angular and a recent additon of VueJs.
Cons
There is no real hot module replacement, where changes made to the source code reflect on the device instantly.
There is a slight overhead by having to run a JavaScript VM, so if performance is really critical NativeScript might not be the right choice. Worth noting that in most cases the performance is very comparable to truly native applications.
There are no ready-made UI collections, so applications have to be built using the default UI elements, and then styled manually.
Likelihood to Recommend
If the goal is to ease future maintenance by not having to develop two separate codebases for the two main platforms then NativeScript might be a great fit. NativeScript is not a good fit for games because of the added overhead of having to run a JavaScript VM that proxies calls to the underlying native layer.
